aboutsummaryrefslogtreecommitdiffstats
path: root/language-model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemAdapterFactory.java
diff options
context:
space:
mode:
Diffstat (limited to 'language-model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemAdapterFactory.java')
-rw-r--r--language-model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemAdapterFactory.java784
1 files changed, 0 insertions, 784 deletions
diff --git a/language-model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemAdapterFactory.java b/language-model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemAdapterFactory.java
deleted file mode 100644
index 07246d70..00000000
--- a/language-model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemAdapterFactory.java
+++ /dev/null
@@ -1,784 +0,0 @@
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 caseUnboundedMultiplicity(UnboundedMultiplicity object) {
181 return createUnboundedMultiplicityAdapter();
182 }
183
184 @Override
185 public Adapter caseVariableOrNodeArgument(VariableOrNodeArgument object) {
186 return createVariableOrNodeArgumentAdapter();
187 }
188
189 @Override
190 public Adapter caseEnumDeclaration(EnumDeclaration object) {
191 return createEnumDeclarationAdapter();
192 }
193
194 @Override
195 public Adapter caseVariableOrNode(VariableOrNode object) {
196 return createVariableOrNodeAdapter();
197 }
198
199 @Override
200 public Adapter caseConstant(Constant object) {
201 return createConstantAdapter();
202 }
203
204 @Override
205 public Adapter caseIntConstant(IntConstant object) {
206 return createIntConstantAdapter();
207 }
208
209 @Override
210 public Adapter caseRealConstant(RealConstant object) {
211 return createRealConstantAdapter();
212 }
213
214 @Override
215 public Adapter caseStringConstant(StringConstant object) {
216 return createStringConstantAdapter();
217 }
218
219 @Override
220 public Adapter caseConstantArgument(ConstantArgument object) {
221 return createConstantArgumentAdapter();
222 }
223
224 @Override
225 public Adapter caseArgument(Argument object) {
226 return createArgumentAdapter();
227 }
228
229 @Override
230 public Adapter caseNodeAssertionArgument(NodeAssertionArgument object) {
231 return createNodeAssertionArgumentAdapter();
232 }
233
234 @Override
235 public Adapter caseAssertionArgument(AssertionArgument object) {
236 return createAssertionArgumentAdapter();
237 }
238
239 @Override
240 public Adapter caseConstantAssertionArgument(ConstantAssertionArgument object) {
241 return createConstantAssertionArgumentAdapter();
242 }
243
244 @Override
245 public Adapter caseNodeValueAssertion(NodeValueAssertion object) {
246 return createNodeValueAssertionAdapter();
247 }
248
249 @Override
250 public Adapter defaultCase(EObject object) {
251 return createEObjectAdapter();
252 }
253 };
254
255 /**
256 * Creates an adapter for the <code>target</code>.
257 * <!-- begin-user-doc -->
258 * <!-- end-user-doc -->
259 * @param target the object to adapt.
260 * @return the adapter for the <code>target</code>.
261 * @generated
262 */
263 @Override
264 public Adapter createAdapter(Notifier target) {
265 return modelSwitch.doSwitch((EObject) target);
266 }
267
268 /**
269 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Problem <em>Problem</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.Problem
276 * @generated
277 */
278 public Adapter createProblemAdapter() {
279 return null;
280 }
281
282 /**
283 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Relation <em>Relation</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.Relation
290 * @generated
291 */
292 public Adapter createRelationAdapter() {
293 return null;
294 }
295
296 /**
297 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ClassDeclaration <em>Class Declaration</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.ClassDeclaration
304 * @generated
305 */
306 public Adapter createClassDeclarationAdapter() {
307 return null;
308 }
309
310 /**
311 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ReferenceDeclaration <em>Reference Declaration</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.ReferenceDeclaration
318 * @generated
319 */
320 public Adapter createReferenceDeclarationAdapter() {
321 return null;
322 }
323
324 /**
325 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.NamedElement <em>Named Element</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.NamedElement
332 * @generated
333 */
334 public Adapter createNamedElementAdapter() {
335 return null;
336 }
337
338 /**
339 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.PredicateDefinition <em>Predicate Definition</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.PredicateDefinition
346 * @generated
347 */
348 public Adapter createPredicateDefinitionAdapter() {
349 return null;
350 }
351
352 /**
353 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Parameter <em>Parameter</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.Parameter
360 * @generated
361 */
362 public Adapter createParameterAdapter() {
363 return null;
364 }
365
366 /**
367 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Variable <em>Variable</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.Variable
374 * @generated
375 */
376 public Adapter createVariableAdapter() {
377 return null;
378 }
379
380 /**
381 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Conjunction <em>Conjunction</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.Conjunction
388 * @generated
389 */
390 public Adapter createConjunctionAdapter() {
391 return null;
392 }
393
394 /**
395 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Literal <em>Literal</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.Literal
402 * @generated
403 */
404 public Adapter createLiteralAdapter() {
405 return null;
406 }
407
408 /**
409 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Atom <em>Atom</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.Atom
416 * @generated
417 */
418 public Adapter createAtomAdapter() {
419 return null;
420 }
421
422 /**
423 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ImplicitVariable <em>Implicit Variable</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.ImplicitVariable
430 * @generated
431 */
432 public Adapter createImplicitVariableAdapter() {
433 return null;
434 }
435
436 /**
437 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.NegativeLiteral <em>Negative Literal</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.NegativeLiteral
444 * @generated
445 */
446 public Adapter createNegativeLiteralAdapter() {
447 return null;
448 }
449
450 /**
451 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ExistentialQuantifier <em>Existential Quantifier</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.ExistentialQuantifier
458 * @generated
459 */
460 public Adapter createExistentialQuantifierAdapter() {
461 return null;
462 }
463
464 /**
465 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Assertion <em>Assertion</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.Assertion
472 * @generated
473 */
474 public Adapter createAssertionAdapter() {
475 return null;
476 }
477
478 /**
479 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Node <em>Node</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.Node
486 * @generated
487 */
488 public Adapter createNodeAdapter() {
489 return null;
490 }
491
492 /**
493 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ScopeDeclaration <em>Scope Declaration</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.ScopeDeclaration
500 * @generated
501 */
502 public Adapter createScopeDeclarationAdapter() {
503 return null;
504 }
505
506 /**
507 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Statement <em>Statement</em>}'.
508 * <!-- begin-user-doc -->
509 * This default implementation returns null so that we can easily ignore cases;
510 * it's useful to ignore a case when inheritance will catch all the cases anyway.
511 * <!-- end-user-doc -->
512 * @return the new adapter.
513 * @see org.eclipse.viatra.solver.language.model.problem.Statement
514 * @generated
515 */
516 public Adapter createStatementAdapter() {
517 return null;
518 }
519
520 /**
521 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.TypeScope <em>Type Scope</em>}'.
522 * <!-- begin-user-doc -->
523 * This default implementation returns null so that we can easily ignore cases;
524 * it's useful to ignore a case when inheritance will catch all the cases anyway.
525 * <!-- end-user-doc -->
526 * @return the new adapter.
527 * @see org.eclipse.viatra.solver.language.model.problem.TypeScope
528 * @generated
529 */
530 public Adapter createTypeScopeAdapter() {
531 return null;
532 }
533
534 /**
535 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Multiplicity <em>Multiplicity</em>}'.
536 * <!-- begin-user-doc -->
537 * This default implementation returns null so that we can easily ignore cases;
538 * it's useful to ignore a case when inheritance will catch all the cases anyway.
539 * <!-- end-user-doc -->
540 * @return the new adapter.
541 * @see org.eclipse.viatra.solver.language.model.problem.Multiplicity
542 * @generated
543 */
544 public Adapter createMultiplicityAdapter() {
545 return null;
546 }
547
548 /**
549 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.RangeMultiplicity <em>Range Multiplicity</em>}'.
550 * <!-- begin-user-doc -->
551 * This default implementation returns null so that we can easily ignore cases;
552 * it's useful to ignore a case when inheritance will catch all the cases anyway.
553 * <!-- end-user-doc -->
554 * @return the new adapter.
555 * @see org.eclipse.viatra.solver.language.model.problem.RangeMultiplicity
556 * @generated
557 */
558 public Adapter createRangeMultiplicityAdapter() {
559 return null;
560 }
561
562 /**
563 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ExactMultiplicity <em>Exact Multiplicity</em>}'.
564 * <!-- begin-user-doc -->
565 * This default implementation returns null so that we can easily ignore cases;
566 * it's useful to ignore a case when inheritance will catch all the cases anyway.
567 * <!-- end-user-doc -->
568 * @return the new adapter.
569 * @see org.eclipse.viatra.solver.language.model.problem.ExactMultiplicity
570 * @generated
571 */
572 public Adapter createExactMultiplicityAdapter() {
573 return null;
574 }
575
576 /**
577 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.UnboundedMultiplicity <em>Unbounded Multiplicity</em>}'.
578 * <!-- begin-user-doc -->
579 * This default implementation returns null so that we can easily ignore cases;
580 * it's useful to ignore a case when inheritance will catch all the cases anyway.
581 * <!-- end-user-doc -->
582 * @return the new adapter.
583 * @see org.eclipse.viatra.solver.language.model.problem.UnboundedMultiplicity
584 * @generated
585 */
586 public Adapter createUnboundedMultiplicityAdapter() {
587 return null;
588 }
589
590 /**
591 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.VariableOrNodeArgument <em>Variable Or Node Argument</em>}'.
592 * <!-- begin-user-doc -->
593 * This default implementation returns null so that we can easily ignore cases;
594 * it's useful to ignore a case when inheritance will catch all the cases anyway.
595 * <!-- end-user-doc -->
596 * @return the new adapter.
597 * @see org.eclipse.viatra.solver.language.model.problem.VariableOrNodeArgument
598 * @generated
599 */
600 public Adapter createVariableOrNodeArgumentAdapter() {
601 return null;
602 }
603
604 /**
605 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Argument <em>Argument</em>}'.
606 * <!-- begin-user-doc -->
607 * This default implementation returns null so that we can easily ignore cases;
608 * it's useful to ignore a case when inheritance will catch all the cases anyway.
609 * <!-- end-user-doc -->
610 * @return the new adapter.
611 * @see org.eclipse.viatra.solver.language.model.problem.Argument
612 * @generated
613 */
614 public Adapter createArgumentAdapter() {
615 return null;
616 }
617
618 /**
619 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.NodeAssertionArgument <em>Node Assertion Argument</em>}'.
620 * <!-- begin-user-doc -->
621 * This default implementation returns null so that we can easily ignore cases;
622 * it's useful to ignore a case when inheritance will catch all the cases anyway.
623 * <!-- end-user-doc -->
624 * @return the new adapter.
625 * @see org.eclipse.viatra.solver.language.model.problem.NodeAssertionArgument
626 * @generated
627 */
628 public Adapter createNodeAssertionArgumentAdapter() {
629 return null;
630 }
631
632 /**
633 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.AssertionArgument <em>Assertion Argument</em>}'.
634 * <!-- begin-user-doc -->
635 * This default implementation returns null so that we can easily ignore cases;
636 * it's useful to ignore a case when inheritance will catch all the cases anyway.
637 * <!-- end-user-doc -->
638 * @return the new adapter.
639 * @see org.eclipse.viatra.solver.language.model.problem.AssertionArgument
640 * @generated
641 */
642 public Adapter createAssertionArgumentAdapter() {
643 return null;
644 }
645
646 /**
647 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ConstantAssertionArgument <em>Constant Assertion Argument</em>}'.
648 * <!-- begin-user-doc -->
649 * This default implementation returns null so that we can easily ignore cases;
650 * it's useful to ignore a case when inheritance will catch all the cases anyway.
651 * <!-- end-user-doc -->
652 * @return the new adapter.
653 * @see org.eclipse.viatra.solver.language.model.problem.ConstantAssertionArgument
654 * @generated
655 */
656 public Adapter createConstantAssertionArgumentAdapter() {
657 return null;
658 }
659
660 /**
661 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.NodeValueAssertion <em>Node Value Assertion</em>}'.
662 * <!-- begin-user-doc -->
663 * This default implementation returns null so that we can easily ignore cases;
664 * it's useful to ignore a case when inheritance will catch all the cases anyway.
665 * <!-- end-user-doc -->
666 * @return the new adapter.
667 * @see org.eclipse.viatra.solver.language.model.problem.NodeValueAssertion
668 * @generated
669 */
670 public Adapter createNodeValueAssertionAdapter() {
671 return null;
672 }
673
674 /**
675 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.EnumDeclaration <em>Enum Declaration</em>}'.
676 * <!-- begin-user-doc -->
677 * This default implementation returns null so that we can easily ignore cases;
678 * it's useful to ignore a case when inheritance will catch all the cases anyway.
679 * <!-- end-user-doc -->
680 * @return the new adapter.
681 * @see org.eclipse.viatra.solver.language.model.problem.EnumDeclaration
682 * @generated
683 */
684 public Adapter createEnumDeclarationAdapter() {
685 return null;
686 }
687
688 /**
689 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.VariableOrNode <em>Variable Or Node</em>}'.
690 * <!-- begin-user-doc -->
691 * This default implementation returns null so that we can easily ignore cases;
692 * it's useful to ignore a case when inheritance will catch all the cases anyway.
693 * <!-- end-user-doc -->
694 * @return the new adapter.
695 * @see org.eclipse.viatra.solver.language.model.problem.VariableOrNode
696 * @generated
697 */
698 public Adapter createVariableOrNodeAdapter() {
699 return null;
700 }
701
702 /**
703 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Constant <em>Constant</em>}'.
704 * <!-- begin-user-doc -->
705 * This default implementation returns null so that we can easily ignore cases;
706 * it's useful to ignore a case when inheritance will catch all the cases anyway.
707 * <!-- end-user-doc -->
708 * @return the new adapter.
709 * @see org.eclipse.viatra.solver.language.model.problem.Constant
710 * @generated
711 */
712 public Adapter createConstantAdapter() {
713 return null;
714 }
715
716 /**
717 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.IntConstant <em>Int Constant</em>}'.
718 * <!-- begin-user-doc -->
719 * This default implementation returns null so that we can easily ignore cases;
720 * it's useful to ignore a case when inheritance will catch all the cases anyway.
721 * <!-- end-user-doc -->
722 * @return the new adapter.
723 * @see org.eclipse.viatra.solver.language.model.problem.IntConstant
724 * @generated
725 */
726 public Adapter createIntConstantAdapter() {
727 return null;
728 }
729
730 /**
731 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.RealConstant <em>Real Constant</em>}'.
732 * <!-- begin-user-doc -->
733 * This default implementation returns null so that we can easily ignore cases;
734 * it's useful to ignore a case when inheritance will catch all the cases anyway.
735 * <!-- end-user-doc -->
736 * @return the new adapter.
737 * @see org.eclipse.viatra.solver.language.model.problem.RealConstant
738 * @generated
739 */
740 public Adapter createRealConstantAdapter() {
741 return null;
742 }
743
744 /**
745 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.StringConstant <em>String Constant</em>}'.
746 * <!-- begin-user-doc -->
747 * This default implementation returns null so that we can easily ignore cases;
748 * it's useful to ignore a case when inheritance will catch all the cases anyway.
749 * <!-- end-user-doc -->
750 * @return the new adapter.
751 * @see org.eclipse.viatra.solver.language.model.problem.StringConstant
752 * @generated
753 */
754 public Adapter createStringConstantAdapter() {
755 return null;
756 }
757
758 /**
759 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ConstantArgument <em>Constant Argument</em>}'.
760 * <!-- begin-user-doc -->
761 * This default implementation returns null so that we can easily ignore cases;
762 * it's useful to ignore a case when inheritance will catch all the cases anyway.
763 * <!-- end-user-doc -->
764 * @return the new adapter.
765 * @see org.eclipse.viatra.solver.language.model.problem.ConstantArgument
766 * @generated
767 */
768 public Adapter createConstantArgumentAdapter() {
769 return null;
770 }
771
772 /**
773 * Creates a new adapter for the default case.
774 * <!-- begin-user-doc -->
775 * This default implementation returns null.
776 * <!-- end-user-doc -->
777 * @return the new adapter.
778 * @generated
779 */
780 public Adapter createEObjectAdapter() {
781 return null;
782 }
783
784} //ProblemAdapterFactory
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-07 16:10:04 +0000