diff options
Diffstat (limited to 'Solvers/SMT-Solver/hu.bme.mit.inf.dslreasoner.smt.language/src-gen/hu/bme/mit/inf/dslreasoner/smtLanguage/util/SmtLanguageAdapterFactory.java')
-rw-r--r-- | Solvers/SMT-Solver/hu.bme.mit.inf.dslreasoner.smt.language/src-gen/hu/bme/mit/inf/dslreasoner/smtLanguage/util/SmtLanguageAdapterFactory.java | 1692 |
1 files changed, 1692 insertions, 0 deletions
diff --git a/Solvers/SMT-Solver/hu.bme.mit.inf.dslreasoner.smt.language/src-gen/hu/bme/mit/inf/dslreasoner/smtLanguage/util/SmtLanguageAdapterFactory.java b/Solvers/SMT-Solver/hu.bme.mit.inf.dslreasoner.smt.language/src-gen/hu/bme/mit/inf/dslreasoner/smtLanguage/util/SmtLanguageAdapterFactory.java new file mode 100644 index 00000000..b296566e --- /dev/null +++ b/Solvers/SMT-Solver/hu.bme.mit.inf.dslreasoner.smt.language/src-gen/hu/bme/mit/inf/dslreasoner/smtLanguage/util/SmtLanguageAdapterFactory.java | |||
@@ -0,0 +1,1692 @@ | |||
1 | /** | ||
2 | */ | ||
3 | package hu.bme.mit.inf.dslreasoner.smtLanguage.util; | ||
4 | |||
5 | import hu.bme.mit.inf.dslreasoner.smtLanguage.*; | ||
6 | |||
7 | import org.eclipse.emf.common.notify.Adapter; | ||
8 | import org.eclipse.emf.common.notify.Notifier; | ||
9 | |||
10 | import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl; | ||
11 | |||
12 | import org.eclipse.emf.ecore.EObject; | ||
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 hu.bme.mit.inf.dslreasoner.smtLanguage.SmtLanguagePackage | ||
20 | * @generated | ||
21 | */ | ||
22 | public class SmtLanguageAdapterFactory extends AdapterFactoryImpl | ||
23 | { | ||
24 | /** | ||
25 | * The cached model package. | ||
26 | * <!-- begin-user-doc --> | ||
27 | * <!-- end-user-doc --> | ||
28 | * @generated | ||
29 | */ | ||
30 | protected static SmtLanguagePackage modelPackage; | ||
31 | |||
32 | /** | ||
33 | * Creates an instance of the adapter factory. | ||
34 | * <!-- begin-user-doc --> | ||
35 | * <!-- end-user-doc --> | ||
36 | * @generated | ||
37 | */ | ||
38 | public SmtLanguageAdapterFactory() | ||
39 | { | ||
40 | if (modelPackage == null) | ||
41 | { | ||
42 | modelPackage = SmtLanguagePackage.eINSTANCE; | ||
43 | } | ||
44 | } | ||
45 | |||
46 | /** | ||
47 | * Returns whether this factory is applicable for the type of the object. | ||
48 | * <!-- begin-user-doc --> | ||
49 | * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model. | ||
50 | * <!-- end-user-doc --> | ||
51 | * @return whether this factory is applicable for the type of the object. | ||
52 | * @generated | ||
53 | */ | ||
54 | @Override | ||
55 | public boolean isFactoryForType(Object object) | ||
56 | { | ||
57 | if (object == modelPackage) | ||
58 | { | ||
59 | return true; | ||
60 | } | ||
61 | if (object instanceof EObject) | ||
62 | { | ||
63 | return ((EObject)object).eClass().getEPackage() == modelPackage; | ||
64 | } | ||
65 | return false; | ||
66 | } | ||
67 | |||
68 | /** | ||
69 | * The switch that delegates to the <code>createXXX</code> methods. | ||
70 | * <!-- begin-user-doc --> | ||
71 | * <!-- end-user-doc --> | ||
72 | * @generated | ||
73 | */ | ||
74 | protected SmtLanguageSwitch<Adapter> modelSwitch = | ||
75 | new SmtLanguageSwitch<Adapter>() | ||
76 | { | ||
77 | @Override | ||
78 | public Adapter caseSMTDocument(SMTDocument object) | ||
79 | { | ||
80 | return createSMTDocumentAdapter(); | ||
81 | } | ||
82 | @Override | ||
83 | public Adapter caseSMTInput(SMTInput object) | ||
84 | { | ||
85 | return createSMTInputAdapter(); | ||
86 | } | ||
87 | @Override | ||
88 | public Adapter caseSMTOutput(SMTOutput object) | ||
89 | { | ||
90 | return createSMTOutputAdapter(); | ||
91 | } | ||
92 | @Override | ||
93 | public Adapter caseSMTOption(SMTOption object) | ||
94 | { | ||
95 | return createSMTOptionAdapter(); | ||
96 | } | ||
97 | @Override | ||
98 | public Adapter caseSMTType(SMTType object) | ||
99 | { | ||
100 | return createSMTTypeAdapter(); | ||
101 | } | ||
102 | @Override | ||
103 | public Adapter caseSMTEnumLiteral(SMTEnumLiteral object) | ||
104 | { | ||
105 | return createSMTEnumLiteralAdapter(); | ||
106 | } | ||
107 | @Override | ||
108 | public Adapter caseSMTEnumeratedTypeDeclaration(SMTEnumeratedTypeDeclaration object) | ||
109 | { | ||
110 | return createSMTEnumeratedTypeDeclarationAdapter(); | ||
111 | } | ||
112 | @Override | ||
113 | public Adapter caseSMTSetTypeDeclaration(SMTSetTypeDeclaration object) | ||
114 | { | ||
115 | return createSMTSetTypeDeclarationAdapter(); | ||
116 | } | ||
117 | @Override | ||
118 | public Adapter caseSMTTypeReference(SMTTypeReference object) | ||
119 | { | ||
120 | return createSMTTypeReferenceAdapter(); | ||
121 | } | ||
122 | @Override | ||
123 | public Adapter caseSMTComplexTypeReference(SMTComplexTypeReference object) | ||
124 | { | ||
125 | return createSMTComplexTypeReferenceAdapter(); | ||
126 | } | ||
127 | @Override | ||
128 | public Adapter caseSMTPrimitiveTypeReference(SMTPrimitiveTypeReference object) | ||
129 | { | ||
130 | return createSMTPrimitiveTypeReferenceAdapter(); | ||
131 | } | ||
132 | @Override | ||
133 | public Adapter caseSMTIntTypeReference(SMTIntTypeReference object) | ||
134 | { | ||
135 | return createSMTIntTypeReferenceAdapter(); | ||
136 | } | ||
137 | @Override | ||
138 | public Adapter caseSMTBoolTypeReference(SMTBoolTypeReference object) | ||
139 | { | ||
140 | return createSMTBoolTypeReferenceAdapter(); | ||
141 | } | ||
142 | @Override | ||
143 | public Adapter caseSMTRealTypeReference(SMTRealTypeReference object) | ||
144 | { | ||
145 | return createSMTRealTypeReferenceAdapter(); | ||
146 | } | ||
147 | @Override | ||
148 | public Adapter caseSMTFunctionDeclaration(SMTFunctionDeclaration object) | ||
149 | { | ||
150 | return createSMTFunctionDeclarationAdapter(); | ||
151 | } | ||
152 | @Override | ||
153 | public Adapter caseSMTFunctionDefinition(SMTFunctionDefinition object) | ||
154 | { | ||
155 | return createSMTFunctionDefinitionAdapter(); | ||
156 | } | ||
157 | @Override | ||
158 | public Adapter caseSMTTerm(SMTTerm object) | ||
159 | { | ||
160 | return createSMTTermAdapter(); | ||
161 | } | ||
162 | @Override | ||
163 | public Adapter caseSMTSymbolicDeclaration(SMTSymbolicDeclaration object) | ||
164 | { | ||
165 | return createSMTSymbolicDeclarationAdapter(); | ||
166 | } | ||
167 | @Override | ||
168 | public Adapter caseSMTSymbolicValue(SMTSymbolicValue object) | ||
169 | { | ||
170 | return createSMTSymbolicValueAdapter(); | ||
171 | } | ||
172 | @Override | ||
173 | public Adapter caseSMTAtomicTerm(SMTAtomicTerm object) | ||
174 | { | ||
175 | return createSMTAtomicTermAdapter(); | ||
176 | } | ||
177 | @Override | ||
178 | public Adapter caseSMTIntLiteral(SMTIntLiteral object) | ||
179 | { | ||
180 | return createSMTIntLiteralAdapter(); | ||
181 | } | ||
182 | @Override | ||
183 | public Adapter caseSMTBoolLiteral(SMTBoolLiteral object) | ||
184 | { | ||
185 | return createSMTBoolLiteralAdapter(); | ||
186 | } | ||
187 | @Override | ||
188 | public Adapter caseSMTRealLiteral(SMTRealLiteral object) | ||
189 | { | ||
190 | return createSMTRealLiteralAdapter(); | ||
191 | } | ||
192 | @Override | ||
193 | public Adapter caseSMTSortedVariable(SMTSortedVariable object) | ||
194 | { | ||
195 | return createSMTSortedVariableAdapter(); | ||
196 | } | ||
197 | @Override | ||
198 | public Adapter caseSMTQuantifiedExpression(SMTQuantifiedExpression object) | ||
199 | { | ||
200 | return createSMTQuantifiedExpressionAdapter(); | ||
201 | } | ||
202 | @Override | ||
203 | public Adapter caseSMTExists(SMTExists object) | ||
204 | { | ||
205 | return createSMTExistsAdapter(); | ||
206 | } | ||
207 | @Override | ||
208 | public Adapter caseSMTForall(SMTForall object) | ||
209 | { | ||
210 | return createSMTForallAdapter(); | ||
211 | } | ||
212 | @Override | ||
213 | public Adapter caseSMTBoolOperation(SMTBoolOperation object) | ||
214 | { | ||
215 | return createSMTBoolOperationAdapter(); | ||
216 | } | ||
217 | @Override | ||
218 | public Adapter caseSMTAnd(SMTAnd object) | ||
219 | { | ||
220 | return createSMTAndAdapter(); | ||
221 | } | ||
222 | @Override | ||
223 | public Adapter caseSMTOr(SMTOr object) | ||
224 | { | ||
225 | return createSMTOrAdapter(); | ||
226 | } | ||
227 | @Override | ||
228 | public Adapter caseSMTImpl(SMTImpl object) | ||
229 | { | ||
230 | return createSMTImplAdapter(); | ||
231 | } | ||
232 | @Override | ||
233 | public Adapter caseSMTNot(SMTNot object) | ||
234 | { | ||
235 | return createSMTNotAdapter(); | ||
236 | } | ||
237 | @Override | ||
238 | public Adapter caseSMTIff(SMTIff object) | ||
239 | { | ||
240 | return createSMTIffAdapter(); | ||
241 | } | ||
242 | @Override | ||
243 | public Adapter caseSMTITE(SMTITE object) | ||
244 | { | ||
245 | return createSMTITEAdapter(); | ||
246 | } | ||
247 | @Override | ||
248 | public Adapter caseSMTLet(SMTLet object) | ||
249 | { | ||
250 | return createSMTLetAdapter(); | ||
251 | } | ||
252 | @Override | ||
253 | public Adapter caseSMTInlineConstantDefinition(SMTInlineConstantDefinition object) | ||
254 | { | ||
255 | return createSMTInlineConstantDefinitionAdapter(); | ||
256 | } | ||
257 | @Override | ||
258 | public Adapter caseSMTRelation(SMTRelation object) | ||
259 | { | ||
260 | return createSMTRelationAdapter(); | ||
261 | } | ||
262 | @Override | ||
263 | public Adapter caseSMTEquals(SMTEquals object) | ||
264 | { | ||
265 | return createSMTEqualsAdapter(); | ||
266 | } | ||
267 | @Override | ||
268 | public Adapter caseSMTDistinct(SMTDistinct object) | ||
269 | { | ||
270 | return createSMTDistinctAdapter(); | ||
271 | } | ||
272 | @Override | ||
273 | public Adapter caseSMTLT(SMTLT object) | ||
274 | { | ||
275 | return createSMTLTAdapter(); | ||
276 | } | ||
277 | @Override | ||
278 | public Adapter caseSMTMT(SMTMT object) | ||
279 | { | ||
280 | return createSMTMTAdapter(); | ||
281 | } | ||
282 | @Override | ||
283 | public Adapter caseSMTLEQ(SMTLEQ object) | ||
284 | { | ||
285 | return createSMTLEQAdapter(); | ||
286 | } | ||
287 | @Override | ||
288 | public Adapter caseSMTMEQ(SMTMEQ object) | ||
289 | { | ||
290 | return createSMTMEQAdapter(); | ||
291 | } | ||
292 | @Override | ||
293 | public Adapter caseSMTIntOperation(SMTIntOperation object) | ||
294 | { | ||
295 | return createSMTIntOperationAdapter(); | ||
296 | } | ||
297 | @Override | ||
298 | public Adapter caseSMTPlus(SMTPlus object) | ||
299 | { | ||
300 | return createSMTPlusAdapter(); | ||
301 | } | ||
302 | @Override | ||
303 | public Adapter caseSMTMinus(SMTMinus object) | ||
304 | { | ||
305 | return createSMTMinusAdapter(); | ||
306 | } | ||
307 | @Override | ||
308 | public Adapter caseSMTMultiply(SMTMultiply object) | ||
309 | { | ||
310 | return createSMTMultiplyAdapter(); | ||
311 | } | ||
312 | @Override | ||
313 | public Adapter caseSMTDivison(SMTDivison object) | ||
314 | { | ||
315 | return createSMTDivisonAdapter(); | ||
316 | } | ||
317 | @Override | ||
318 | public Adapter caseSMTDiv(SMTDiv object) | ||
319 | { | ||
320 | return createSMTDivAdapter(); | ||
321 | } | ||
322 | @Override | ||
323 | public Adapter caseSMTMod(SMTMod object) | ||
324 | { | ||
325 | return createSMTModAdapter(); | ||
326 | } | ||
327 | @Override | ||
328 | public Adapter caseSMTAssertion(SMTAssertion object) | ||
329 | { | ||
330 | return createSMTAssertionAdapter(); | ||
331 | } | ||
332 | @Override | ||
333 | public Adapter caseSMTCardinalityConstraint(SMTCardinalityConstraint object) | ||
334 | { | ||
335 | return createSMTCardinalityConstraintAdapter(); | ||
336 | } | ||
337 | @Override | ||
338 | public Adapter caseSMTSatCommand(SMTSatCommand object) | ||
339 | { | ||
340 | return createSMTSatCommandAdapter(); | ||
341 | } | ||
342 | @Override | ||
343 | public Adapter caseSMTSimpleSatCommand(SMTSimpleSatCommand object) | ||
344 | { | ||
345 | return createSMTSimpleSatCommandAdapter(); | ||
346 | } | ||
347 | @Override | ||
348 | public Adapter caseSMTComplexSatCommand(SMTComplexSatCommand object) | ||
349 | { | ||
350 | return createSMTComplexSatCommandAdapter(); | ||
351 | } | ||
352 | @Override | ||
353 | public Adapter caseSMTGetModelCommand(SMTGetModelCommand object) | ||
354 | { | ||
355 | return createSMTGetModelCommandAdapter(); | ||
356 | } | ||
357 | @Override | ||
358 | public Adapter caseSMTReasoningTactic(SMTReasoningTactic object) | ||
359 | { | ||
360 | return createSMTReasoningTacticAdapter(); | ||
361 | } | ||
362 | @Override | ||
363 | public Adapter caseSMTBuiltinTactic(SMTBuiltinTactic object) | ||
364 | { | ||
365 | return createSMTBuiltinTacticAdapter(); | ||
366 | } | ||
367 | @Override | ||
368 | public Adapter caseSMTReasoningCombinator(SMTReasoningCombinator object) | ||
369 | { | ||
370 | return createSMTReasoningCombinatorAdapter(); | ||
371 | } | ||
372 | @Override | ||
373 | public Adapter caseSMTAndThenCombinator(SMTAndThenCombinator object) | ||
374 | { | ||
375 | return createSMTAndThenCombinatorAdapter(); | ||
376 | } | ||
377 | @Override | ||
378 | public Adapter caseSMTOrElseCombinator(SMTOrElseCombinator object) | ||
379 | { | ||
380 | return createSMTOrElseCombinatorAdapter(); | ||
381 | } | ||
382 | @Override | ||
383 | public Adapter caseSMTParOrCombinator(SMTParOrCombinator object) | ||
384 | { | ||
385 | return createSMTParOrCombinatorAdapter(); | ||
386 | } | ||
387 | @Override | ||
388 | public Adapter caseSMTParThenCombinator(SMTParThenCombinator object) | ||
389 | { | ||
390 | return createSMTParThenCombinatorAdapter(); | ||
391 | } | ||
392 | @Override | ||
393 | public Adapter caseSMTTryForCombinator(SMTTryForCombinator object) | ||
394 | { | ||
395 | return createSMTTryForCombinatorAdapter(); | ||
396 | } | ||
397 | @Override | ||
398 | public Adapter caseSMTIfCombinator(SMTIfCombinator object) | ||
399 | { | ||
400 | return createSMTIfCombinatorAdapter(); | ||
401 | } | ||
402 | @Override | ||
403 | public Adapter caseSMTWhenCombinator(SMTWhenCombinator object) | ||
404 | { | ||
405 | return createSMTWhenCombinatorAdapter(); | ||
406 | } | ||
407 | @Override | ||
408 | public Adapter caseSMTFailIfCombinator(SMTFailIfCombinator object) | ||
409 | { | ||
410 | return createSMTFailIfCombinatorAdapter(); | ||
411 | } | ||
412 | @Override | ||
413 | public Adapter caseSMTUsingParamCombinator(SMTUsingParamCombinator object) | ||
414 | { | ||
415 | return createSMTUsingParamCombinatorAdapter(); | ||
416 | } | ||
417 | @Override | ||
418 | public Adapter caseReasoningProbe(ReasoningProbe object) | ||
419 | { | ||
420 | return createReasoningProbeAdapter(); | ||
421 | } | ||
422 | @Override | ||
423 | public Adapter caseReasoningTacticParameter(ReasoningTacticParameter object) | ||
424 | { | ||
425 | return createReasoningTacticParameterAdapter(); | ||
426 | } | ||
427 | @Override | ||
428 | public Adapter caseSMTResult(SMTResult object) | ||
429 | { | ||
430 | return createSMTResultAdapter(); | ||
431 | } | ||
432 | @Override | ||
433 | public Adapter caseSMTErrorResult(SMTErrorResult object) | ||
434 | { | ||
435 | return createSMTErrorResultAdapter(); | ||
436 | } | ||
437 | @Override | ||
438 | public Adapter caseSMTUnsupportedResult(SMTUnsupportedResult object) | ||
439 | { | ||
440 | return createSMTUnsupportedResultAdapter(); | ||
441 | } | ||
442 | @Override | ||
443 | public Adapter caseSMTSatResult(SMTSatResult object) | ||
444 | { | ||
445 | return createSMTSatResultAdapter(); | ||
446 | } | ||
447 | @Override | ||
448 | public Adapter caseSMTModelResult(SMTModelResult object) | ||
449 | { | ||
450 | return createSMTModelResultAdapter(); | ||
451 | } | ||
452 | @Override | ||
453 | public Adapter caseSMTStatisticValue(SMTStatisticValue object) | ||
454 | { | ||
455 | return createSMTStatisticValueAdapter(); | ||
456 | } | ||
457 | @Override | ||
458 | public Adapter caseSMTStatisticIntValue(SMTStatisticIntValue object) | ||
459 | { | ||
460 | return createSMTStatisticIntValueAdapter(); | ||
461 | } | ||
462 | @Override | ||
463 | public Adapter caseSMTStatisticDoubleValue(SMTStatisticDoubleValue object) | ||
464 | { | ||
465 | return createSMTStatisticDoubleValueAdapter(); | ||
466 | } | ||
467 | @Override | ||
468 | public Adapter caseSMTStatisticsSection(SMTStatisticsSection object) | ||
469 | { | ||
470 | return createSMTStatisticsSectionAdapter(); | ||
471 | } | ||
472 | @Override | ||
473 | public Adapter defaultCase(EObject object) | ||
474 | { | ||
475 | return createEObjectAdapter(); | ||
476 | } | ||
477 | }; | ||
478 | |||
479 | /** | ||
480 | * Creates an adapter for the <code>target</code>. | ||
481 | * <!-- begin-user-doc --> | ||
482 | * <!-- end-user-doc --> | ||
483 | * @param target the object to adapt. | ||
484 | * @return the adapter for the <code>target</code>. | ||
485 | * @generated | ||
486 | */ | ||
487 | @Override | ||
488 | public Adapter createAdapter(Notifier target) | ||
489 | { | ||
490 | return modelSwitch.doSwitch((EObject)target); | ||
491 | } | ||
492 | |||
493 | |||
494 | /** | ||
495 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTDocument <em>SMT Document</em>}'. | ||
496 | * <!-- begin-user-doc --> | ||
497 | * This default implementation returns null so that we can easily ignore cases; | ||
498 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
499 | * <!-- end-user-doc --> | ||
500 | * @return the new adapter. | ||
501 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTDocument | ||
502 | * @generated | ||
503 | */ | ||
504 | public Adapter createSMTDocumentAdapter() | ||
505 | { | ||
506 | return null; | ||
507 | } | ||
508 | |||
509 | /** | ||
510 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTInput <em>SMT Input</em>}'. | ||
511 | * <!-- begin-user-doc --> | ||
512 | * This default implementation returns null so that we can easily ignore cases; | ||
513 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
514 | * <!-- end-user-doc --> | ||
515 | * @return the new adapter. | ||
516 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTInput | ||
517 | * @generated | ||
518 | */ | ||
519 | public Adapter createSMTInputAdapter() | ||
520 | { | ||
521 | return null; | ||
522 | } | ||
523 | |||
524 | /** | ||
525 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTOutput <em>SMT Output</em>}'. | ||
526 | * <!-- begin-user-doc --> | ||
527 | * This default implementation returns null so that we can easily ignore cases; | ||
528 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
529 | * <!-- end-user-doc --> | ||
530 | * @return the new adapter. | ||
531 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTOutput | ||
532 | * @generated | ||
533 | */ | ||
534 | public Adapter createSMTOutputAdapter() | ||
535 | { | ||
536 | return null; | ||
537 | } | ||
538 | |||
539 | /** | ||
540 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTOption <em>SMT Option</em>}'. | ||
541 | * <!-- begin-user-doc --> | ||
542 | * This default implementation returns null so that we can easily ignore cases; | ||
543 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
544 | * <!-- end-user-doc --> | ||
545 | * @return the new adapter. | ||
546 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTOption | ||
547 | * @generated | ||
548 | */ | ||
549 | public Adapter createSMTOptionAdapter() | ||
550 | { | ||
551 | return null; | ||
552 | } | ||
553 | |||
554 | /** | ||
555 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTType <em>SMT Type</em>}'. | ||
556 | * <!-- begin-user-doc --> | ||
557 | * This default implementation returns null so that we can easily ignore cases; | ||
558 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
559 | * <!-- end-user-doc --> | ||
560 | * @return the new adapter. | ||
561 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTType | ||
562 | * @generated | ||
563 | */ | ||
564 | public Adapter createSMTTypeAdapter() | ||
565 | { | ||
566 | return null; | ||
567 | } | ||
568 | |||
569 | /** | ||
570 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTEnumLiteral <em>SMT Enum Literal</em>}'. | ||
571 | * <!-- begin-user-doc --> | ||
572 | * This default implementation returns null so that we can easily ignore cases; | ||
573 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
574 | * <!-- end-user-doc --> | ||
575 | * @return the new adapter. | ||
576 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTEnumLiteral | ||
577 | * @generated | ||
578 | */ | ||
579 | public Adapter createSMTEnumLiteralAdapter() | ||
580 | { | ||
581 | return null; | ||
582 | } | ||
583 | |||
584 | /** | ||
585 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTEnumeratedTypeDeclaration <em>SMT Enumerated Type Declaration</em>}'. | ||
586 | * <!-- begin-user-doc --> | ||
587 | * This default implementation returns null so that we can easily ignore cases; | ||
588 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
589 | * <!-- end-user-doc --> | ||
590 | * @return the new adapter. | ||
591 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTEnumeratedTypeDeclaration | ||
592 | * @generated | ||
593 | */ | ||
594 | public Adapter createSMTEnumeratedTypeDeclarationAdapter() | ||
595 | { | ||
596 | return null; | ||
597 | } | ||
598 | |||
599 | /** | ||
600 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSetTypeDeclaration <em>SMT Set Type Declaration</em>}'. | ||
601 | * <!-- begin-user-doc --> | ||
602 | * This default implementation returns null so that we can easily ignore cases; | ||
603 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
604 | * <!-- end-user-doc --> | ||
605 | * @return the new adapter. | ||
606 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSetTypeDeclaration | ||
607 | * @generated | ||
608 | */ | ||
609 | public Adapter createSMTSetTypeDeclarationAdapter() | ||
610 | { | ||
611 | return null; | ||
612 | } | ||
613 | |||
614 | /** | ||
615 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTTypeReference <em>SMT Type Reference</em>}'. | ||
616 | * <!-- begin-user-doc --> | ||
617 | * This default implementation returns null so that we can easily ignore cases; | ||
618 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
619 | * <!-- end-user-doc --> | ||
620 | * @return the new adapter. | ||
621 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTTypeReference | ||
622 | * @generated | ||
623 | */ | ||
624 | public Adapter createSMTTypeReferenceAdapter() | ||
625 | { | ||
626 | return null; | ||
627 | } | ||
628 | |||
629 | /** | ||
630 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTComplexTypeReference <em>SMT Complex Type Reference</em>}'. | ||
631 | * <!-- begin-user-doc --> | ||
632 | * This default implementation returns null so that we can easily ignore cases; | ||
633 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
634 | * <!-- end-user-doc --> | ||
635 | * @return the new adapter. | ||
636 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTComplexTypeReference | ||
637 | * @generated | ||
638 | */ | ||
639 | public Adapter createSMTComplexTypeReferenceAdapter() | ||
640 | { | ||
641 | return null; | ||
642 | } | ||
643 | |||
644 | /** | ||
645 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTPrimitiveTypeReference <em>SMT Primitive Type Reference</em>}'. | ||
646 | * <!-- begin-user-doc --> | ||
647 | * This default implementation returns null so that we can easily ignore cases; | ||
648 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
649 | * <!-- end-user-doc --> | ||
650 | * @return the new adapter. | ||
651 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTPrimitiveTypeReference | ||
652 | * @generated | ||
653 | */ | ||
654 | public Adapter createSMTPrimitiveTypeReferenceAdapter() | ||
655 | { | ||
656 | return null; | ||
657 | } | ||
658 | |||
659 | /** | ||
660 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTIntTypeReference <em>SMT Int Type Reference</em>}'. | ||
661 | * <!-- begin-user-doc --> | ||
662 | * This default implementation returns null so that we can easily ignore cases; | ||
663 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
664 | * <!-- end-user-doc --> | ||
665 | * @return the new adapter. | ||
666 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTIntTypeReference | ||
667 | * @generated | ||
668 | */ | ||
669 | public Adapter createSMTIntTypeReferenceAdapter() | ||
670 | { | ||
671 | return null; | ||
672 | } | ||
673 | |||
674 | /** | ||
675 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTBoolTypeReference <em>SMT Bool Type Reference</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 hu.bme.mit.inf.dslreasoner.smtLanguage.SMTBoolTypeReference | ||
682 | * @generated | ||
683 | */ | ||
684 | public Adapter createSMTBoolTypeReferenceAdapter() | ||
685 | { | ||
686 | return null; | ||
687 | } | ||
688 | |||
689 | /** | ||
690 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTRealTypeReference <em>SMT Real Type Reference</em>}'. | ||
691 | * <!-- begin-user-doc --> | ||
692 | * This default implementation returns null so that we can easily ignore cases; | ||
693 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
694 | * <!-- end-user-doc --> | ||
695 | * @return the new adapter. | ||
696 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTRealTypeReference | ||
697 | * @generated | ||
698 | */ | ||
699 | public Adapter createSMTRealTypeReferenceAdapter() | ||
700 | { | ||
701 | return null; | ||
702 | } | ||
703 | |||
704 | /** | ||
705 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTFunctionDeclaration <em>SMT Function Declaration</em>}'. | ||
706 | * <!-- begin-user-doc --> | ||
707 | * This default implementation returns null so that we can easily ignore cases; | ||
708 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
709 | * <!-- end-user-doc --> | ||
710 | * @return the new adapter. | ||
711 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTFunctionDeclaration | ||
712 | * @generated | ||
713 | */ | ||
714 | public Adapter createSMTFunctionDeclarationAdapter() | ||
715 | { | ||
716 | return null; | ||
717 | } | ||
718 | |||
719 | /** | ||
720 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTFunctionDefinition <em>SMT Function Definition</em>}'. | ||
721 | * <!-- begin-user-doc --> | ||
722 | * This default implementation returns null so that we can easily ignore cases; | ||
723 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
724 | * <!-- end-user-doc --> | ||
725 | * @return the new adapter. | ||
726 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTFunctionDefinition | ||
727 | * @generated | ||
728 | */ | ||
729 | public Adapter createSMTFunctionDefinitionAdapter() | ||
730 | { | ||
731 | return null; | ||
732 | } | ||
733 | |||
734 | /** | ||
735 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTTerm <em>SMT Term</em>}'. | ||
736 | * <!-- begin-user-doc --> | ||
737 | * This default implementation returns null so that we can easily ignore cases; | ||
738 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
739 | * <!-- end-user-doc --> | ||
740 | * @return the new adapter. | ||
741 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTTerm | ||
742 | * @generated | ||
743 | */ | ||
744 | public Adapter createSMTTermAdapter() | ||
745 | { | ||
746 | return null; | ||
747 | } | ||
748 | |||
749 | /** | ||
750 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSymbolicDeclaration <em>SMT Symbolic Declaration</em>}'. | ||
751 | * <!-- begin-user-doc --> | ||
752 | * This default implementation returns null so that we can easily ignore cases; | ||
753 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
754 | * <!-- end-user-doc --> | ||
755 | * @return the new adapter. | ||
756 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSymbolicDeclaration | ||
757 | * @generated | ||
758 | */ | ||
759 | public Adapter createSMTSymbolicDeclarationAdapter() | ||
760 | { | ||
761 | return null; | ||
762 | } | ||
763 | |||
764 | /** | ||
765 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSymbolicValue <em>SMT Symbolic Value</em>}'. | ||
766 | * <!-- begin-user-doc --> | ||
767 | * This default implementation returns null so that we can easily ignore cases; | ||
768 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
769 | * <!-- end-user-doc --> | ||
770 | * @return the new adapter. | ||
771 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSymbolicValue | ||
772 | * @generated | ||
773 | */ | ||
774 | public Adapter createSMTSymbolicValueAdapter() | ||
775 | { | ||
776 | return null; | ||
777 | } | ||
778 | |||
779 | /** | ||
780 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTAtomicTerm <em>SMT Atomic Term</em>}'. | ||
781 | * <!-- begin-user-doc --> | ||
782 | * This default implementation returns null so that we can easily ignore cases; | ||
783 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
784 | * <!-- end-user-doc --> | ||
785 | * @return the new adapter. | ||
786 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTAtomicTerm | ||
787 | * @generated | ||
788 | */ | ||
789 | public Adapter createSMTAtomicTermAdapter() | ||
790 | { | ||
791 | return null; | ||
792 | } | ||
793 | |||
794 | /** | ||
795 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTIntLiteral <em>SMT Int Literal</em>}'. | ||
796 | * <!-- begin-user-doc --> | ||
797 | * This default implementation returns null so that we can easily ignore cases; | ||
798 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
799 | * <!-- end-user-doc --> | ||
800 | * @return the new adapter. | ||
801 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTIntLiteral | ||
802 | * @generated | ||
803 | */ | ||
804 | public Adapter createSMTIntLiteralAdapter() | ||
805 | { | ||
806 | return null; | ||
807 | } | ||
808 | |||
809 | /** | ||
810 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTBoolLiteral <em>SMT Bool Literal</em>}'. | ||
811 | * <!-- begin-user-doc --> | ||
812 | * This default implementation returns null so that we can easily ignore cases; | ||
813 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
814 | * <!-- end-user-doc --> | ||
815 | * @return the new adapter. | ||
816 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTBoolLiteral | ||
817 | * @generated | ||
818 | */ | ||
819 | public Adapter createSMTBoolLiteralAdapter() | ||
820 | { | ||
821 | return null; | ||
822 | } | ||
823 | |||
824 | /** | ||
825 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTRealLiteral <em>SMT Real Literal</em>}'. | ||
826 | * <!-- begin-user-doc --> | ||
827 | * This default implementation returns null so that we can easily ignore cases; | ||
828 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
829 | * <!-- end-user-doc --> | ||
830 | * @return the new adapter. | ||
831 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTRealLiteral | ||
832 | * @generated | ||
833 | */ | ||
834 | public Adapter createSMTRealLiteralAdapter() | ||
835 | { | ||
836 | return null; | ||
837 | } | ||
838 | |||
839 | /** | ||
840 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSortedVariable <em>SMT Sorted Variable</em>}'. | ||
841 | * <!-- begin-user-doc --> | ||
842 | * This default implementation returns null so that we can easily ignore cases; | ||
843 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
844 | * <!-- end-user-doc --> | ||
845 | * @return the new adapter. | ||
846 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSortedVariable | ||
847 | * @generated | ||
848 | */ | ||
849 | public Adapter createSMTSortedVariableAdapter() | ||
850 | { | ||
851 | return null; | ||
852 | } | ||
853 | |||
854 | /** | ||
855 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTQuantifiedExpression <em>SMT Quantified Expression</em>}'. | ||
856 | * <!-- begin-user-doc --> | ||
857 | * This default implementation returns null so that we can easily ignore cases; | ||
858 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
859 | * <!-- end-user-doc --> | ||
860 | * @return the new adapter. | ||
861 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTQuantifiedExpression | ||
862 | * @generated | ||
863 | */ | ||
864 | public Adapter createSMTQuantifiedExpressionAdapter() | ||
865 | { | ||
866 | return null; | ||
867 | } | ||
868 | |||
869 | /** | ||
870 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTExists <em>SMT Exists</em>}'. | ||
871 | * <!-- begin-user-doc --> | ||
872 | * This default implementation returns null so that we can easily ignore cases; | ||
873 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
874 | * <!-- end-user-doc --> | ||
875 | * @return the new adapter. | ||
876 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTExists | ||
877 | * @generated | ||
878 | */ | ||
879 | public Adapter createSMTExistsAdapter() | ||
880 | { | ||
881 | return null; | ||
882 | } | ||
883 | |||
884 | /** | ||
885 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTForall <em>SMT Forall</em>}'. | ||
886 | * <!-- begin-user-doc --> | ||
887 | * This default implementation returns null so that we can easily ignore cases; | ||
888 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
889 | * <!-- end-user-doc --> | ||
890 | * @return the new adapter. | ||
891 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTForall | ||
892 | * @generated | ||
893 | */ | ||
894 | public Adapter createSMTForallAdapter() | ||
895 | { | ||
896 | return null; | ||
897 | } | ||
898 | |||
899 | /** | ||
900 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTBoolOperation <em>SMT Bool Operation</em>}'. | ||
901 | * <!-- begin-user-doc --> | ||
902 | * This default implementation returns null so that we can easily ignore cases; | ||
903 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
904 | * <!-- end-user-doc --> | ||
905 | * @return the new adapter. | ||
906 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTBoolOperation | ||
907 | * @generated | ||
908 | */ | ||
909 | public Adapter createSMTBoolOperationAdapter() | ||
910 | { | ||
911 | return null; | ||
912 | } | ||
913 | |||
914 | /** | ||
915 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTAnd <em>SMT And</em>}'. | ||
916 | * <!-- begin-user-doc --> | ||
917 | * This default implementation returns null so that we can easily ignore cases; | ||
918 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
919 | * <!-- end-user-doc --> | ||
920 | * @return the new adapter. | ||
921 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTAnd | ||
922 | * @generated | ||
923 | */ | ||
924 | public Adapter createSMTAndAdapter() | ||
925 | { | ||
926 | return null; | ||
927 | } | ||
928 | |||
929 | /** | ||
930 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTOr <em>SMT Or</em>}'. | ||
931 | * <!-- begin-user-doc --> | ||
932 | * This default implementation returns null so that we can easily ignore cases; | ||
933 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
934 | * <!-- end-user-doc --> | ||
935 | * @return the new adapter. | ||
936 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTOr | ||
937 | * @generated | ||
938 | */ | ||
939 | public Adapter createSMTOrAdapter() | ||
940 | { | ||
941 | return null; | ||
942 | } | ||
943 | |||
944 | /** | ||
945 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTImpl <em>SMT Impl</em>}'. | ||
946 | * <!-- begin-user-doc --> | ||
947 | * This default implementation returns null so that we can easily ignore cases; | ||
948 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
949 | * <!-- end-user-doc --> | ||
950 | * @return the new adapter. | ||
951 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTImpl | ||
952 | * @generated | ||
953 | */ | ||
954 | public Adapter createSMTImplAdapter() | ||
955 | { | ||
956 | return null; | ||
957 | } | ||
958 | |||
959 | /** | ||
960 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTNot <em>SMT Not</em>}'. | ||
961 | * <!-- begin-user-doc --> | ||
962 | * This default implementation returns null so that we can easily ignore cases; | ||
963 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
964 | * <!-- end-user-doc --> | ||
965 | * @return the new adapter. | ||
966 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTNot | ||
967 | * @generated | ||
968 | */ | ||
969 | public Adapter createSMTNotAdapter() | ||
970 | { | ||
971 | return null; | ||
972 | } | ||
973 | |||
974 | /** | ||
975 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTIff <em>SMT Iff</em>}'. | ||
976 | * <!-- begin-user-doc --> | ||
977 | * This default implementation returns null so that we can easily ignore cases; | ||
978 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
979 | * <!-- end-user-doc --> | ||
980 | * @return the new adapter. | ||
981 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTIff | ||
982 | * @generated | ||
983 | */ | ||
984 | public Adapter createSMTIffAdapter() | ||
985 | { | ||
986 | return null; | ||
987 | } | ||
988 | |||
989 | /** | ||
990 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTITE <em>SMTITE</em>}'. | ||
991 | * <!-- begin-user-doc --> | ||
992 | * This default implementation returns null so that we can easily ignore cases; | ||
993 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
994 | * <!-- end-user-doc --> | ||
995 | * @return the new adapter. | ||
996 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTITE | ||
997 | * @generated | ||
998 | */ | ||
999 | public Adapter createSMTITEAdapter() | ||
1000 | { | ||
1001 | return null; | ||
1002 | } | ||
1003 | |||
1004 | /** | ||
1005 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTLet <em>SMT Let</em>}'. | ||
1006 | * <!-- begin-user-doc --> | ||
1007 | * This default implementation returns null so that we can easily ignore cases; | ||
1008 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1009 | * <!-- end-user-doc --> | ||
1010 | * @return the new adapter. | ||
1011 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTLet | ||
1012 | * @generated | ||
1013 | */ | ||
1014 | public Adapter createSMTLetAdapter() | ||
1015 | { | ||
1016 | return null; | ||
1017 | } | ||
1018 | |||
1019 | /** | ||
1020 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTInlineConstantDefinition <em>SMT Inline Constant Definition</em>}'. | ||
1021 | * <!-- begin-user-doc --> | ||
1022 | * This default implementation returns null so that we can easily ignore cases; | ||
1023 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1024 | * <!-- end-user-doc --> | ||
1025 | * @return the new adapter. | ||
1026 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTInlineConstantDefinition | ||
1027 | * @generated | ||
1028 | */ | ||
1029 | public Adapter createSMTInlineConstantDefinitionAdapter() | ||
1030 | { | ||
1031 | return null; | ||
1032 | } | ||
1033 | |||
1034 | /** | ||
1035 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTRelation <em>SMT Relation</em>}'. | ||
1036 | * <!-- begin-user-doc --> | ||
1037 | * This default implementation returns null so that we can easily ignore cases; | ||
1038 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1039 | * <!-- end-user-doc --> | ||
1040 | * @return the new adapter. | ||
1041 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTRelation | ||
1042 | * @generated | ||
1043 | */ | ||
1044 | public Adapter createSMTRelationAdapter() | ||
1045 | { | ||
1046 | return null; | ||
1047 | } | ||
1048 | |||
1049 | /** | ||
1050 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTEquals <em>SMT Equals</em>}'. | ||
1051 | * <!-- begin-user-doc --> | ||
1052 | * This default implementation returns null so that we can easily ignore cases; | ||
1053 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1054 | * <!-- end-user-doc --> | ||
1055 | * @return the new adapter. | ||
1056 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTEquals | ||
1057 | * @generated | ||
1058 | */ | ||
1059 | public Adapter createSMTEqualsAdapter() | ||
1060 | { | ||
1061 | return null; | ||
1062 | } | ||
1063 | |||
1064 | /** | ||
1065 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTDistinct <em>SMT Distinct</em>}'. | ||
1066 | * <!-- begin-user-doc --> | ||
1067 | * This default implementation returns null so that we can easily ignore cases; | ||
1068 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1069 | * <!-- end-user-doc --> | ||
1070 | * @return the new adapter. | ||
1071 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTDistinct | ||
1072 | * @generated | ||
1073 | */ | ||
1074 | public Adapter createSMTDistinctAdapter() | ||
1075 | { | ||
1076 | return null; | ||
1077 | } | ||
1078 | |||
1079 | /** | ||
1080 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTLT <em>SMTLT</em>}'. | ||
1081 | * <!-- begin-user-doc --> | ||
1082 | * This default implementation returns null so that we can easily ignore cases; | ||
1083 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1084 | * <!-- end-user-doc --> | ||
1085 | * @return the new adapter. | ||
1086 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTLT | ||
1087 | * @generated | ||
1088 | */ | ||
1089 | public Adapter createSMTLTAdapter() | ||
1090 | { | ||
1091 | return null; | ||
1092 | } | ||
1093 | |||
1094 | /** | ||
1095 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTMT <em>SMTMT</em>}'. | ||
1096 | * <!-- begin-user-doc --> | ||
1097 | * This default implementation returns null so that we can easily ignore cases; | ||
1098 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1099 | * <!-- end-user-doc --> | ||
1100 | * @return the new adapter. | ||
1101 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTMT | ||
1102 | * @generated | ||
1103 | */ | ||
1104 | public Adapter createSMTMTAdapter() | ||
1105 | { | ||
1106 | return null; | ||
1107 | } | ||
1108 | |||
1109 | /** | ||
1110 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTLEQ <em>SMTLEQ</em>}'. | ||
1111 | * <!-- begin-user-doc --> | ||
1112 | * This default implementation returns null so that we can easily ignore cases; | ||
1113 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1114 | * <!-- end-user-doc --> | ||
1115 | * @return the new adapter. | ||
1116 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTLEQ | ||
1117 | * @generated | ||
1118 | */ | ||
1119 | public Adapter createSMTLEQAdapter() | ||
1120 | { | ||
1121 | return null; | ||
1122 | } | ||
1123 | |||
1124 | /** | ||
1125 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTMEQ <em>SMTMEQ</em>}'. | ||
1126 | * <!-- begin-user-doc --> | ||
1127 | * This default implementation returns null so that we can easily ignore cases; | ||
1128 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1129 | * <!-- end-user-doc --> | ||
1130 | * @return the new adapter. | ||
1131 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTMEQ | ||
1132 | * @generated | ||
1133 | */ | ||
1134 | public Adapter createSMTMEQAdapter() | ||
1135 | { | ||
1136 | return null; | ||
1137 | } | ||
1138 | |||
1139 | /** | ||
1140 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTIntOperation <em>SMT Int Operation</em>}'. | ||
1141 | * <!-- begin-user-doc --> | ||
1142 | * This default implementation returns null so that we can easily ignore cases; | ||
1143 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1144 | * <!-- end-user-doc --> | ||
1145 | * @return the new adapter. | ||
1146 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTIntOperation | ||
1147 | * @generated | ||
1148 | */ | ||
1149 | public Adapter createSMTIntOperationAdapter() | ||
1150 | { | ||
1151 | return null; | ||
1152 | } | ||
1153 | |||
1154 | /** | ||
1155 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTPlus <em>SMT Plus</em>}'. | ||
1156 | * <!-- begin-user-doc --> | ||
1157 | * This default implementation returns null so that we can easily ignore cases; | ||
1158 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1159 | * <!-- end-user-doc --> | ||
1160 | * @return the new adapter. | ||
1161 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTPlus | ||
1162 | * @generated | ||
1163 | */ | ||
1164 | public Adapter createSMTPlusAdapter() | ||
1165 | { | ||
1166 | return null; | ||
1167 | } | ||
1168 | |||
1169 | /** | ||
1170 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTMinus <em>SMT Minus</em>}'. | ||
1171 | * <!-- begin-user-doc --> | ||
1172 | * This default implementation returns null so that we can easily ignore cases; | ||
1173 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1174 | * <!-- end-user-doc --> | ||
1175 | * @return the new adapter. | ||
1176 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTMinus | ||
1177 | * @generated | ||
1178 | */ | ||
1179 | public Adapter createSMTMinusAdapter() | ||
1180 | { | ||
1181 | return null; | ||
1182 | } | ||
1183 | |||
1184 | /** | ||
1185 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTMultiply <em>SMT Multiply</em>}'. | ||
1186 | * <!-- begin-user-doc --> | ||
1187 | * This default implementation returns null so that we can easily ignore cases; | ||
1188 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1189 | * <!-- end-user-doc --> | ||
1190 | * @return the new adapter. | ||
1191 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTMultiply | ||
1192 | * @generated | ||
1193 | */ | ||
1194 | public Adapter createSMTMultiplyAdapter() | ||
1195 | { | ||
1196 | return null; | ||
1197 | } | ||
1198 | |||
1199 | /** | ||
1200 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTDivison <em>SMT Divison</em>}'. | ||
1201 | * <!-- begin-user-doc --> | ||
1202 | * This default implementation returns null so that we can easily ignore cases; | ||
1203 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1204 | * <!-- end-user-doc --> | ||
1205 | * @return the new adapter. | ||
1206 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTDivison | ||
1207 | * @generated | ||
1208 | */ | ||
1209 | public Adapter createSMTDivisonAdapter() | ||
1210 | { | ||
1211 | return null; | ||
1212 | } | ||
1213 | |||
1214 | /** | ||
1215 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTDiv <em>SMT Div</em>}'. | ||
1216 | * <!-- begin-user-doc --> | ||
1217 | * This default implementation returns null so that we can easily ignore cases; | ||
1218 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1219 | * <!-- end-user-doc --> | ||
1220 | * @return the new adapter. | ||
1221 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTDiv | ||
1222 | * @generated | ||
1223 | */ | ||
1224 | public Adapter createSMTDivAdapter() | ||
1225 | { | ||
1226 | return null; | ||
1227 | } | ||
1228 | |||
1229 | /** | ||
1230 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTMod <em>SMT Mod</em>}'. | ||
1231 | * <!-- begin-user-doc --> | ||
1232 | * This default implementation returns null so that we can easily ignore cases; | ||
1233 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1234 | * <!-- end-user-doc --> | ||
1235 | * @return the new adapter. | ||
1236 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTMod | ||
1237 | * @generated | ||
1238 | */ | ||
1239 | public Adapter createSMTModAdapter() | ||
1240 | { | ||
1241 | return null; | ||
1242 | } | ||
1243 | |||
1244 | /** | ||
1245 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTAssertion <em>SMT Assertion</em>}'. | ||
1246 | * <!-- begin-user-doc --> | ||
1247 | * This default implementation returns null so that we can easily ignore cases; | ||
1248 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1249 | * <!-- end-user-doc --> | ||
1250 | * @return the new adapter. | ||
1251 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTAssertion | ||
1252 | * @generated | ||
1253 | */ | ||
1254 | public Adapter createSMTAssertionAdapter() | ||
1255 | { | ||
1256 | return null; | ||
1257 | } | ||
1258 | |||
1259 | /** | ||
1260 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTCardinalityConstraint <em>SMT Cardinality Constraint</em>}'. | ||
1261 | * <!-- begin-user-doc --> | ||
1262 | * This default implementation returns null so that we can easily ignore cases; | ||
1263 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1264 | * <!-- end-user-doc --> | ||
1265 | * @return the new adapter. | ||
1266 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTCardinalityConstraint | ||
1267 | * @generated | ||
1268 | */ | ||
1269 | public Adapter createSMTCardinalityConstraintAdapter() | ||
1270 | { | ||
1271 | return null; | ||
1272 | } | ||
1273 | |||
1274 | /** | ||
1275 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSatCommand <em>SMT Sat Command</em>}'. | ||
1276 | * <!-- begin-user-doc --> | ||
1277 | * This default implementation returns null so that we can easily ignore cases; | ||
1278 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1279 | * <!-- end-user-doc --> | ||
1280 | * @return the new adapter. | ||
1281 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSatCommand | ||
1282 | * @generated | ||
1283 | */ | ||
1284 | public Adapter createSMTSatCommandAdapter() | ||
1285 | { | ||
1286 | return null; | ||
1287 | } | ||
1288 | |||
1289 | /** | ||
1290 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSimpleSatCommand <em>SMT Simple Sat Command</em>}'. | ||
1291 | * <!-- begin-user-doc --> | ||
1292 | * This default implementation returns null so that we can easily ignore cases; | ||
1293 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1294 | * <!-- end-user-doc --> | ||
1295 | * @return the new adapter. | ||
1296 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSimpleSatCommand | ||
1297 | * @generated | ||
1298 | */ | ||
1299 | public Adapter createSMTSimpleSatCommandAdapter() | ||
1300 | { | ||
1301 | return null; | ||
1302 | } | ||
1303 | |||
1304 | /** | ||
1305 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTComplexSatCommand <em>SMT Complex Sat Command</em>}'. | ||
1306 | * <!-- begin-user-doc --> | ||
1307 | * This default implementation returns null so that we can easily ignore cases; | ||
1308 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1309 | * <!-- end-user-doc --> | ||
1310 | * @return the new adapter. | ||
1311 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTComplexSatCommand | ||
1312 | * @generated | ||
1313 | */ | ||
1314 | public Adapter createSMTComplexSatCommandAdapter() | ||
1315 | { | ||
1316 | return null; | ||
1317 | } | ||
1318 | |||
1319 | /** | ||
1320 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTGetModelCommand <em>SMT Get Model Command</em>}'. | ||
1321 | * <!-- begin-user-doc --> | ||
1322 | * This default implementation returns null so that we can easily ignore cases; | ||
1323 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1324 | * <!-- end-user-doc --> | ||
1325 | * @return the new adapter. | ||
1326 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTGetModelCommand | ||
1327 | * @generated | ||
1328 | */ | ||
1329 | public Adapter createSMTGetModelCommandAdapter() | ||
1330 | { | ||
1331 | return null; | ||
1332 | } | ||
1333 | |||
1334 | /** | ||
1335 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTReasoningTactic <em>SMT Reasoning Tactic</em>}'. | ||
1336 | * <!-- begin-user-doc --> | ||
1337 | * This default implementation returns null so that we can easily ignore cases; | ||
1338 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1339 | * <!-- end-user-doc --> | ||
1340 | * @return the new adapter. | ||
1341 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTReasoningTactic | ||
1342 | * @generated | ||
1343 | */ | ||
1344 | public Adapter createSMTReasoningTacticAdapter() | ||
1345 | { | ||
1346 | return null; | ||
1347 | } | ||
1348 | |||
1349 | /** | ||
1350 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTBuiltinTactic <em>SMT Builtin Tactic</em>}'. | ||
1351 | * <!-- begin-user-doc --> | ||
1352 | * This default implementation returns null so that we can easily ignore cases; | ||
1353 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1354 | * <!-- end-user-doc --> | ||
1355 | * @return the new adapter. | ||
1356 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTBuiltinTactic | ||
1357 | * @generated | ||
1358 | */ | ||
1359 | public Adapter createSMTBuiltinTacticAdapter() | ||
1360 | { | ||
1361 | return null; | ||
1362 | } | ||
1363 | |||
1364 | /** | ||
1365 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTReasoningCombinator <em>SMT Reasoning Combinator</em>}'. | ||
1366 | * <!-- begin-user-doc --> | ||
1367 | * This default implementation returns null so that we can easily ignore cases; | ||
1368 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1369 | * <!-- end-user-doc --> | ||
1370 | * @return the new adapter. | ||
1371 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTReasoningCombinator | ||
1372 | * @generated | ||
1373 | */ | ||
1374 | public Adapter createSMTReasoningCombinatorAdapter() | ||
1375 | { | ||
1376 | return null; | ||
1377 | } | ||
1378 | |||
1379 | /** | ||
1380 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTAndThenCombinator <em>SMT And Then Combinator</em>}'. | ||
1381 | * <!-- begin-user-doc --> | ||
1382 | * This default implementation returns null so that we can easily ignore cases; | ||
1383 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1384 | * <!-- end-user-doc --> | ||
1385 | * @return the new adapter. | ||
1386 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTAndThenCombinator | ||
1387 | * @generated | ||
1388 | */ | ||
1389 | public Adapter createSMTAndThenCombinatorAdapter() | ||
1390 | { | ||
1391 | return null; | ||
1392 | } | ||
1393 | |||
1394 | /** | ||
1395 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTOrElseCombinator <em>SMT Or Else Combinator</em>}'. | ||
1396 | * <!-- begin-user-doc --> | ||
1397 | * This default implementation returns null so that we can easily ignore cases; | ||
1398 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1399 | * <!-- end-user-doc --> | ||
1400 | * @return the new adapter. | ||
1401 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTOrElseCombinator | ||
1402 | * @generated | ||
1403 | */ | ||
1404 | public Adapter createSMTOrElseCombinatorAdapter() | ||
1405 | { | ||
1406 | return null; | ||
1407 | } | ||
1408 | |||
1409 | /** | ||
1410 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTParOrCombinator <em>SMT Par Or Combinator</em>}'. | ||
1411 | * <!-- begin-user-doc --> | ||
1412 | * This default implementation returns null so that we can easily ignore cases; | ||
1413 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1414 | * <!-- end-user-doc --> | ||
1415 | * @return the new adapter. | ||
1416 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTParOrCombinator | ||
1417 | * @generated | ||
1418 | */ | ||
1419 | public Adapter createSMTParOrCombinatorAdapter() | ||
1420 | { | ||
1421 | return null; | ||
1422 | } | ||
1423 | |||
1424 | /** | ||
1425 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTParThenCombinator <em>SMT Par Then Combinator</em>}'. | ||
1426 | * <!-- begin-user-doc --> | ||
1427 | * This default implementation returns null so that we can easily ignore cases; | ||
1428 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1429 | * <!-- end-user-doc --> | ||
1430 | * @return the new adapter. | ||
1431 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTParThenCombinator | ||
1432 | * @generated | ||
1433 | */ | ||
1434 | public Adapter createSMTParThenCombinatorAdapter() | ||
1435 | { | ||
1436 | return null; | ||
1437 | } | ||
1438 | |||
1439 | /** | ||
1440 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTTryForCombinator <em>SMT Try For Combinator</em>}'. | ||
1441 | * <!-- begin-user-doc --> | ||
1442 | * This default implementation returns null so that we can easily ignore cases; | ||
1443 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1444 | * <!-- end-user-doc --> | ||
1445 | * @return the new adapter. | ||
1446 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTTryForCombinator | ||
1447 | * @generated | ||
1448 | */ | ||
1449 | public Adapter createSMTTryForCombinatorAdapter() | ||
1450 | { | ||
1451 | return null; | ||
1452 | } | ||
1453 | |||
1454 | /** | ||
1455 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTIfCombinator <em>SMT If Combinator</em>}'. | ||
1456 | * <!-- begin-user-doc --> | ||
1457 | * This default implementation returns null so that we can easily ignore cases; | ||
1458 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1459 | * <!-- end-user-doc --> | ||
1460 | * @return the new adapter. | ||
1461 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTIfCombinator | ||
1462 | * @generated | ||
1463 | */ | ||
1464 | public Adapter createSMTIfCombinatorAdapter() | ||
1465 | { | ||
1466 | return null; | ||
1467 | } | ||
1468 | |||
1469 | /** | ||
1470 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTWhenCombinator <em>SMT When Combinator</em>}'. | ||
1471 | * <!-- begin-user-doc --> | ||
1472 | * This default implementation returns null so that we can easily ignore cases; | ||
1473 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1474 | * <!-- end-user-doc --> | ||
1475 | * @return the new adapter. | ||
1476 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTWhenCombinator | ||
1477 | * @generated | ||
1478 | */ | ||
1479 | public Adapter createSMTWhenCombinatorAdapter() | ||
1480 | { | ||
1481 | return null; | ||
1482 | } | ||
1483 | |||
1484 | /** | ||
1485 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTFailIfCombinator <em>SMT Fail If Combinator</em>}'. | ||
1486 | * <!-- begin-user-doc --> | ||
1487 | * This default implementation returns null so that we can easily ignore cases; | ||
1488 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1489 | * <!-- end-user-doc --> | ||
1490 | * @return the new adapter. | ||
1491 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTFailIfCombinator | ||
1492 | * @generated | ||
1493 | */ | ||
1494 | public Adapter createSMTFailIfCombinatorAdapter() | ||
1495 | { | ||
1496 | return null; | ||
1497 | } | ||
1498 | |||
1499 | /** | ||
1500 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTUsingParamCombinator <em>SMT Using Param Combinator</em>}'. | ||
1501 | * <!-- begin-user-doc --> | ||
1502 | * This default implementation returns null so that we can easily ignore cases; | ||
1503 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1504 | * <!-- end-user-doc --> | ||
1505 | * @return the new adapter. | ||
1506 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTUsingParamCombinator | ||
1507 | * @generated | ||
1508 | */ | ||
1509 | public Adapter createSMTUsingParamCombinatorAdapter() | ||
1510 | { | ||
1511 | return null; | ||
1512 | } | ||
1513 | |||
1514 | /** | ||
1515 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.ReasoningProbe <em>Reasoning Probe</em>}'. | ||
1516 | * <!-- begin-user-doc --> | ||
1517 | * This default implementation returns null so that we can easily ignore cases; | ||
1518 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1519 | * <!-- end-user-doc --> | ||
1520 | * @return the new adapter. | ||
1521 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.ReasoningProbe | ||
1522 | * @generated | ||
1523 | */ | ||
1524 | public Adapter createReasoningProbeAdapter() | ||
1525 | { | ||
1526 | return null; | ||
1527 | } | ||
1528 | |||
1529 | /** | ||
1530 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.ReasoningTacticParameter <em>Reasoning Tactic Parameter</em>}'. | ||
1531 | * <!-- begin-user-doc --> | ||
1532 | * This default implementation returns null so that we can easily ignore cases; | ||
1533 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1534 | * <!-- end-user-doc --> | ||
1535 | * @return the new adapter. | ||
1536 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.ReasoningTacticParameter | ||
1537 | * @generated | ||
1538 | */ | ||
1539 | public Adapter createReasoningTacticParameterAdapter() | ||
1540 | { | ||
1541 | return null; | ||
1542 | } | ||
1543 | |||
1544 | /** | ||
1545 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTResult <em>SMT Result</em>}'. | ||
1546 | * <!-- begin-user-doc --> | ||
1547 | * This default implementation returns null so that we can easily ignore cases; | ||
1548 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1549 | * <!-- end-user-doc --> | ||
1550 | * @return the new adapter. | ||
1551 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTResult | ||
1552 | * @generated | ||
1553 | */ | ||
1554 | public Adapter createSMTResultAdapter() | ||
1555 | { | ||
1556 | return null; | ||
1557 | } | ||
1558 | |||
1559 | /** | ||
1560 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTErrorResult <em>SMT Error Result</em>}'. | ||
1561 | * <!-- begin-user-doc --> | ||
1562 | * This default implementation returns null so that we can easily ignore cases; | ||
1563 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1564 | * <!-- end-user-doc --> | ||
1565 | * @return the new adapter. | ||
1566 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTErrorResult | ||
1567 | * @generated | ||
1568 | */ | ||
1569 | public Adapter createSMTErrorResultAdapter() | ||
1570 | { | ||
1571 | return null; | ||
1572 | } | ||
1573 | |||
1574 | /** | ||
1575 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTUnsupportedResult <em>SMT Unsupported Result</em>}'. | ||
1576 | * <!-- begin-user-doc --> | ||
1577 | * This default implementation returns null so that we can easily ignore cases; | ||
1578 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1579 | * <!-- end-user-doc --> | ||
1580 | * @return the new adapter. | ||
1581 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTUnsupportedResult | ||
1582 | * @generated | ||
1583 | */ | ||
1584 | public Adapter createSMTUnsupportedResultAdapter() | ||
1585 | { | ||
1586 | return null; | ||
1587 | } | ||
1588 | |||
1589 | /** | ||
1590 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSatResult <em>SMT Sat Result</em>}'. | ||
1591 | * <!-- begin-user-doc --> | ||
1592 | * This default implementation returns null so that we can easily ignore cases; | ||
1593 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1594 | * <!-- end-user-doc --> | ||
1595 | * @return the new adapter. | ||
1596 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSatResult | ||
1597 | * @generated | ||
1598 | */ | ||
1599 | public Adapter createSMTSatResultAdapter() | ||
1600 | { | ||
1601 | return null; | ||
1602 | } | ||
1603 | |||
1604 | /** | ||
1605 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTModelResult <em>SMT Model Result</em>}'. | ||
1606 | * <!-- begin-user-doc --> | ||
1607 | * This default implementation returns null so that we can easily ignore cases; | ||
1608 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1609 | * <!-- end-user-doc --> | ||
1610 | * @return the new adapter. | ||
1611 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTModelResult | ||
1612 | * @generated | ||
1613 | */ | ||
1614 | public Adapter createSMTModelResultAdapter() | ||
1615 | { | ||
1616 | return null; | ||
1617 | } | ||
1618 | |||
1619 | /** | ||
1620 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTStatisticValue <em>SMT Statistic Value</em>}'. | ||
1621 | * <!-- begin-user-doc --> | ||
1622 | * This default implementation returns null so that we can easily ignore cases; | ||
1623 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1624 | * <!-- end-user-doc --> | ||
1625 | * @return the new adapter. | ||
1626 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTStatisticValue | ||
1627 | * @generated | ||
1628 | */ | ||
1629 | public Adapter createSMTStatisticValueAdapter() | ||
1630 | { | ||
1631 | return null; | ||
1632 | } | ||
1633 | |||
1634 | /** | ||
1635 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTStatisticIntValue <em>SMT Statistic Int Value</em>}'. | ||
1636 | * <!-- begin-user-doc --> | ||
1637 | * This default implementation returns null so that we can easily ignore cases; | ||
1638 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1639 | * <!-- end-user-doc --> | ||
1640 | * @return the new adapter. | ||
1641 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTStatisticIntValue | ||
1642 | * @generated | ||
1643 | */ | ||
1644 | public Adapter createSMTStatisticIntValueAdapter() | ||
1645 | { | ||
1646 | return null; | ||
1647 | } | ||
1648 | |||
1649 | /** | ||
1650 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTStatisticDoubleValue <em>SMT Statistic Double Value</em>}'. | ||
1651 | * <!-- begin-user-doc --> | ||
1652 | * This default implementation returns null so that we can easily ignore cases; | ||
1653 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1654 | * <!-- end-user-doc --> | ||
1655 | * @return the new adapter. | ||
1656 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTStatisticDoubleValue | ||
1657 | * @generated | ||
1658 | */ | ||
1659 | public Adapter createSMTStatisticDoubleValueAdapter() | ||
1660 | { | ||
1661 | return null; | ||
1662 | } | ||
1663 | |||
1664 | /** | ||
1665 | * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.smtLanguage.SMTStatisticsSection <em>SMT Statistics Section</em>}'. | ||
1666 | * <!-- begin-user-doc --> | ||
1667 | * This default implementation returns null so that we can easily ignore cases; | ||
1668 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
1669 | * <!-- end-user-doc --> | ||
1670 | * @return the new adapter. | ||
1671 | * @see hu.bme.mit.inf.dslreasoner.smtLanguage.SMTStatisticsSection | ||
1672 | * @generated | ||
1673 | */ | ||
1674 | public Adapter createSMTStatisticsSectionAdapter() | ||
1675 | { | ||
1676 | return null; | ||
1677 | } | ||
1678 | |||
1679 | /** | ||
1680 | * Creates a new adapter for the default case. | ||
1681 | * <!-- begin-user-doc --> | ||
1682 | * This default implementation returns null. | ||
1683 | * <!-- end-user-doc --> | ||
1684 | * @return the new adapter. | ||
1685 | * @generated | ||
1686 | */ | ||
1687 | public Adapter createEObjectAdapter() | ||
1688 | { | ||
1689 | return null; | ||
1690 | } | ||
1691 | |||
1692 | } //SmtLanguageAdapterFactory | ||