1 files changed, 1620 insertions, 0 deletions

diff --git a/Application/org.eclipse.viatra.solver.language.model/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageAdapterFactory.java b/Application/org.eclipse.viatra.solver.language.model/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageAdapterFactory.java
new file mode 100644
index 00000000..f182e6d2
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.model/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageAdapterFactory.java
@@ -0,0 +1,1620 @@
+/**
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.util;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+
+import org.eclipse.emf.ecore.EObject;
+
+import org.eclipse.viatra.solver.language.solverLanguage.*;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Adapter Factory</b> for the model.
+ * It provides an adapter <code>createXXX</code> method for each class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage
+ * @generated
+ */
+public class SolverLanguageAdapterFactory extends AdapterFactoryImpl {
+        /**
+         * The cached model package.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        protected static SolverLanguagePackage modelPackage;
+
+        /**
+         * Creates an instance of the adapter factory.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        public SolverLanguageAdapterFactory() {
+                if (modelPackage == null) {
+                        modelPackage = SolverLanguagePackage.eINSTANCE;
+                }
+        }
+
+        /**
+         * Returns whether this factory is applicable for the type of the object.
+         * <!-- begin-user-doc -->
+         * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
+         * <!-- end-user-doc -->
+         * @return whether this factory is applicable for the type of the object.
+         * @generated
+         */
+        @Override
+        public boolean isFactoryForType(Object object) {
+                if (object == modelPackage) {
+                        return true;
+                }
+                if (object instanceof EObject) {
+                        return ((EObject) object).eClass().getEPackage() == modelPackage;
+                }
+                return false;
+        }
+
+        /**
+         * The switch that delegates to the <code>createXXX</code> methods.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        protected SolverLanguageSwitch<Adapter> modelSwitch = new SolverLanguageSwitch<Adapter>() {
+                @Override
+                public Adapter casePathComponent(PathComponent object) {
+                        return createPathComponentAdapter();
+                }
+
+                @Override
+                public Adapter caseSymbol(Symbol object) {
+                        return createSymbolAdapter();
+                }
+
+                @Override
+                public Adapter caseCall(Call object) {
+                        return createCallAdapter();
+                }
+
+                @Override
+                public Adapter caseReference(Reference object) {
+                        return createReferenceAdapter();
+                }
+
+                @Override
+                public Adapter caseExpression(Expression object) {
+                        return createExpressionAdapter();
+                }
+
+                @Override
+                public Adapter caseArgument(Argument object) {
+                        return createArgumentAdapter();
+                }
+
+                @Override
+                public Adapter caseArgumentList(ArgumentList object) {
+                        return createArgumentListAdapter();
+                }
+
+                @Override
+                public Adapter caseExpressionArgument(ExpressionArgument object) {
+                        return createExpressionArgumentAdapter();
+                }
+
+                @Override
+                public Adapter caseStarArgument(StarArgument object) {
+                        return createStarArgumentAdapter();
+                }
+
+                @Override
+                public Adapter caseTypedArgument(TypedArgument object) {
+                        return createTypedArgumentAdapter();
+                }
+
+                @Override
+                public Adapter caseMultiaryExpession(MultiaryExpession object) {
+                        return createMultiaryExpessionAdapter();
+                }
+
+                @Override
+                public Adapter caseVariable(Variable object) {
+                        return createVariableAdapter();
+                }
+
+                @Override
+                public Adapter caseUnaryExpression(UnaryExpression object) {
+                        return createUnaryExpressionAdapter();
+                }
+
+                @Override
+                public Adapter caseBinaryExpression(BinaryExpression object) {
+                        return createBinaryExpressionAdapter();
+                }
+
+                @Override
+                public Adapter caseDisjunction(Disjunction object) {
+                        return createDisjunctionAdapter();
+                }
+
+                @Override
+                public Adapter caseConjunction(Conjunction object) {
+                        return createConjunctionAdapter();
+                }
+
+                @Override
+                public Adapter caseConditionalExpression(ConditionalExpression object) {
+                        return createConditionalExpressionAdapter();
+                }
+
+                @Override
+                public Adapter caseSwitch(Switch object) {
+                        return createSwitchAdapter();
+                }
+
+                @Override
+                public Adapter caseCase(Case object) {
+                        return createCaseAdapter();
+                }
+
+                @Override
+                public Adapter caseLetExpression(LetExpression object) {
+                        return createLetExpressionAdapter();
+                }
+
+                @Override
+                public Adapter caseLetBinding(LetBinding object) {
+                        return createLetBindingAdapter();
+                }
+
+                @Override
+                public Adapter caseLiteral(Literal object) {
+                        return createLiteralAdapter();
+                }
+
+                @Override
+                public Adapter caseIntLiteral(IntLiteral object) {
+                        return createIntLiteralAdapter();
+                }
+
+                @Override
+                public Adapter caseRealLiteral(RealLiteral object) {
+                        return createRealLiteralAdapter();
+                }
+
+                @Override
+                public Adapter caseStringLiteral(StringLiteral object) {
+                        return createStringLiteralAdapter();
+                }
+
+                @Override
+                public Adapter caseLogicLiteral(LogicLiteral object) {
+                        return createLogicLiteralAdapter();
+                }
+
+                @Override
+                public Adapter caseEmptyLiteral(EmptyLiteral object) {
+                        return createEmptyLiteralAdapter();
+                }
+
+                @Override
+                public Adapter caseCastExpression(CastExpression object) {
+                        return createCastExpressionAdapter();
+                }
+
+                @Override
+                public Adapter caseAggregateExpression(AggregateExpression object) {
+                        return createAggregateExpressionAdapter();
+                }
+
+                @Override
+                public Adapter caseCount(Count object) {
+                        return createCountAdapter();
+                }
+
+                @Override
+                public Adapter caseAggregation(Aggregation object) {
+                        return createAggregationAdapter();
+                }
+
+                @Override
+                public Adapter caseForall(Forall object) {
+                        return createForallAdapter();
+                }
+
+                @Override
+                public Adapter caseTypeReference(TypeReference object) {
+                        return createTypeReferenceAdapter();
+                }
+
+                @Override
+                public Adapter caseInfinityLiteral(InfinityLiteral object) {
+                        return createInfinityLiteralAdapter();
+                }
+
+                @Override
+                public Adapter caseInterval(Interval object) {
+                        return createIntervalAdapter();
+                }
+
+                @Override
+                public Adapter caseFunctor(Functor object) {
+                        return createFunctorAdapter();
+                }
+
+                @Override
+                public Adapter caseRelation(Relation object) {
+                        return createRelationAdapter();
+                }
+
+                @Override
+                public Adapter caseBaseRelation(BaseRelation object) {
+                        return createBaseRelationAdapter();
+                }
+
+                @Override
+                public Adapter casePredicate(Predicate object) {
+                        return createPredicateAdapter();
+                }
+
+                @Override
+                public Adapter caseDatatype(Datatype object) {
+                        return createDatatypeAdapter();
+                }
+
+                @Override
+                public Adapter caseFunction(Function object) {
+                        return createFunctionAdapter();
+                }
+
+                @Override
+                public Adapter caseMetric(Metric object) {
+                        return createMetricAdapter();
+                }
+
+                @Override
+                public Adapter caseOperator(Operator object) {
+                        return createOperatorAdapter();
+                }
+
+                @Override
+                public Adapter caseNode(Node object) {
+                        return createNodeAdapter();
+                }
+
+                @Override
+                public Adapter caseStatement(Statement object) {
+                        return createStatementAdapter();
+                }
+
+                @Override
+                public Adapter caseAbstractAssertion(AbstractAssertion object) {
+                        return createAbstractAssertionAdapter();
+                }
+
+                @Override
+                public Adapter caseFunctorDefiniton(FunctorDefiniton object) {
+                        return createFunctorDefinitonAdapter();
+                }
+
+                @Override
+                public Adapter casePredicateDefinition(PredicateDefinition object) {
+                        return createPredicateDefinitionAdapter();
+                }
+
+                @Override
+                public Adapter caseFunctionDefinition(FunctionDefinition object) {
+                        return createFunctionDefinitionAdapter();
+                }
+
+                @Override
+                public Adapter caseAttribute(Attribute object) {
+                        return createAttributeAdapter();
+                }
+
+                @Override
+                public Adapter caseExternDeclaration(ExternDeclaration object) {
+                        return createExternDeclarationAdapter();
+                }
+
+                @Override
+                public Adapter caseExternFunctorDeclaration(ExternFunctorDeclaration object) {
+                        return createExternFunctorDeclarationAdapter();
+                }
+
+                @Override
+                public Adapter caseExternPredicateDeclaration(ExternPredicateDeclaration object) {
+                        return createExternPredicateDeclarationAdapter();
+                }
+
+                @Override
+                public Adapter caseExternFunctionDeclaration(ExternFunctionDeclaration object) {
+                        return createExternFunctionDeclarationAdapter();
+                }
+
+                @Override
+                public Adapter caseExternAggregationOperatorDeclaration(ExternAggregationOperatorDeclaration object) {
+                        return createExternAggregationOperatorDeclarationAdapter();
+                }
+
+                @Override
+                public Adapter caseExternDatatypeDeclaration(ExternDatatypeDeclaration object) {
+                        return createExternDatatypeDeclarationAdapter();
+                }
+
+                @Override
+                public Adapter caseClassDeclaration(ClassDeclaration object) {
+                        return createClassDeclarationAdapter();
+                }
+
+                @Override
+                public Adapter caseEnumDeclaration(EnumDeclaration object) {
+                        return createEnumDeclarationAdapter();
+                }
+
+                @Override
+                public Adapter caseEnumLiteral(EnumLiteral object) {
+                        return createEnumLiteralAdapter();
+                }
+
+                @Override
+                public Adapter caseField(Field object) {
+                        return createFieldAdapter();
+                }
+
+                @Override
+                public Adapter caseMultiplicity(Multiplicity object) {
+                        return createMultiplicityAdapter();
+                }
+
+                @Override
+                public Adapter caseDefaultAssertion(DefaultAssertion object) {
+                        return createDefaultAssertionAdapter();
+                }
+
+                @Override
+                public Adapter caseAssertion(Assertion object) {
+                        return createAssertionAdapter();
+                }
+
+                @Override
+                public Adapter caseUnboundedMultiplicity(UnboundedMultiplicity object) {
+                        return createUnboundedMultiplicityAdapter();
+                }
+
+                @Override
+                public Adapter caseExactMultiplicity(ExactMultiplicity object) {
+                        return createExactMultiplicityAdapter();
+                }
+
+                @Override
+                public Adapter caseBoundedMultiplicity(BoundedMultiplicity object) {
+                        return createBoundedMultiplicityAdapter();
+                }
+
+                @Override
+                public Adapter caseInlinePredicateAttrributes(InlinePredicateAttrributes object) {
+                        return createInlinePredicateAttrributesAdapter();
+                }
+
+                @Override
+                public Adapter caseAggregationOperator(AggregationOperator object) {
+                        return createAggregationOperatorAdapter();
+                }
+
+                @Override
+                public Adapter caseProblem(Problem object) {
+                        return createProblemAdapter();
+                }
+
+                @Override
+                public Adapter caseTypedStarArgument(TypedStarArgument object) {
+                        return createTypedStarArgumentAdapter();
+                }
+
+                @Override
+                public Adapter caseTypedVariableArgument(TypedVariableArgument object) {
+                        return createTypedVariableArgumentAdapter();
+                }
+
+                @Override
+                public Adapter caseUnnamedErrorPredicateDefintion(UnnamedErrorPredicateDefintion object) {
+                        return createUnnamedErrorPredicateDefintionAdapter();
+                }
+
+                @Override
+                public Adapter caseObjectiveDeclaration(ObjectiveDeclaration object) {
+                        return createObjectiveDeclarationAdapter();
+                }
+
+                @Override
+                public Adapter caseScopeDeclaration(ScopeDeclaration object) {
+                        return createScopeDeclarationAdapter();
+                }
+
+                @Override
+                public Adapter caseExactScope(ExactScope object) {
+                        return createExactScopeAdapter();
+                }
+
+                @Override
+                public Adapter caseBoundedScope(BoundedScope object) {
+                        return createBoundedScopeAdapter();
+                }
+
+                @Override
+                public Adapter caseLowerBoundedScope(LowerBoundedScope object) {
+                        return createLowerBoundedScopeAdapter();
+                }
+
+                @Override
+                public Adapter caseNamespaceImport(NamespaceImport object) {
+                        return createNamespaceImportAdapter();
+                }
+
+                @Override
+                public Adapter caseImport(Import object) {
+                        return createImportAdapter();
+                }
+
+                @Override
+                public Adapter caseUriImport(UriImport object) {
+                        return createUriImportAdapter();
+                }
+
+                @Override
+                public Adapter defaultCase(EObject object) {
+                        return createEObjectAdapter();
+                }
+        };
+
+        /**
+         * Creates an adapter for the <code>target</code>.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @param target the object to adapt.
+         * @return the adapter for the <code>target</code>.
+         * @generated
+         */
+        @Override
+        public Adapter createAdapter(Notifier target) {
+                return modelSwitch.doSwitch((EObject) target);
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.PathComponent <em>Path Component</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.PathComponent
+         * @generated
+         */
+        public Adapter createPathComponentAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Symbol <em>Symbol</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Symbol
+         * @generated
+         */
+        public Adapter createSymbolAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Call <em>Call</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Call
+         * @generated
+         */
+        public Adapter createCallAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Reference <em>Reference</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Reference
+         * @generated
+         */
+        public Adapter createReferenceAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Expression <em>Expression</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Expression
+         * @generated
+         */
+        public Adapter createExpressionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Argument <em>Argument</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Argument
+         * @generated
+         */
+        public Adapter createArgumentAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ArgumentList <em>Argument List</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.ArgumentList
+         * @generated
+         */
+        public Adapter createArgumentListAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument <em>Expression Argument</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument
+         * @generated
+         */
+        public Adapter createExpressionArgumentAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.StarArgument <em>Star Argument</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.StarArgument
+         * @generated
+         */
+        public Adapter createStarArgumentAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.TypedArgument <em>Typed Argument</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.TypedArgument
+         * @generated
+         */
+        public Adapter createTypedArgumentAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiaryExpession <em>Multiary Expession</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.MultiaryExpession
+         * @generated
+         */
+        public Adapter createMultiaryExpessionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Variable <em>Variable</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Variable
+         * @generated
+         */
+        public Adapter createVariableAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression <em>Unary Expression</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression
+         * @generated
+         */
+        public Adapter createUnaryExpressionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression <em>Binary Expression</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression
+         * @generated
+         */
+        public Adapter createBinaryExpressionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Disjunction <em>Disjunction</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Disjunction
+         * @generated
+         */
+        public Adapter createDisjunctionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Conjunction <em>Conjunction</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Conjunction
+         * @generated
+         */
+        public Adapter createConjunctionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ConditionalExpression <em>Conditional Expression</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.ConditionalExpression
+         * @generated
+         */
+        public Adapter createConditionalExpressionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Switch <em>Switch</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Switch
+         * @generated
+         */
+        public Adapter createSwitchAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Case <em>Case</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Case
+         * @generated
+         */
+        public Adapter createCaseAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.LetExpression <em>Let Expression</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.LetExpression
+         * @generated
+         */
+        public Adapter createLetExpressionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.LetBinding <em>Let Binding</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.LetBinding
+         * @generated
+         */
+        public Adapter createLetBindingAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Literal <em>Literal</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Literal
+         * @generated
+         */
+        public Adapter createLiteralAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.IntLiteral <em>Int Literal</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.IntLiteral
+         * @generated
+         */
+        public Adapter createIntLiteralAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.RealLiteral <em>Real Literal</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.RealLiteral
+         * @generated
+         */
+        public Adapter createRealLiteralAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.StringLiteral <em>String Literal</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.StringLiteral
+         * @generated
+         */
+        public Adapter createStringLiteralAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral <em>Logic Literal</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral
+         * @generated
+         */
+        public Adapter createLogicLiteralAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.EmptyLiteral <em>Empty Literal</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.EmptyLiteral
+         * @generated
+         */
+        public Adapter createEmptyLiteralAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.CastExpression <em>Cast Expression</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.CastExpression
+         * @generated
+         */
+        public Adapter createCastExpressionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.AggregateExpression <em>Aggregate Expression</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.AggregateExpression
+         * @generated
+         */
+        public Adapter createAggregateExpressionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Count <em>Count</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Count
+         * @generated
+         */
+        public Adapter createCountAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Aggregation <em>Aggregation</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Aggregation
+         * @generated
+         */
+        public Adapter createAggregationAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Forall <em>Forall</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Forall
+         * @generated
+         */
+        public Adapter createForallAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.TypeReference <em>Type Reference</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.TypeReference
+         * @generated
+         */
+        public Adapter createTypeReferenceAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.InfinityLiteral <em>Infinity Literal</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.InfinityLiteral
+         * @generated
+         */
+        public Adapter createInfinityLiteralAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Interval <em>Interval</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Interval
+         * @generated
+         */
+        public Adapter createIntervalAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Functor <em>Functor</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Functor
+         * @generated
+         */
+        public Adapter createFunctorAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Relation <em>Relation</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Relation
+         * @generated
+         */
+        public Adapter createRelationAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BaseRelation <em>Base Relation</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.BaseRelation
+         * @generated
+         */
+        public Adapter createBaseRelationAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate <em>Predicate</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Predicate
+         * @generated
+         */
+        public Adapter createPredicateAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Datatype <em>Datatype</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Datatype
+         * @generated
+         */
+        public Adapter createDatatypeAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Function <em>Function</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Function
+         * @generated
+         */
+        public Adapter createFunctionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Metric <em>Metric</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Metric
+         * @generated
+         */
+        public Adapter createMetricAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Operator <em>Operator</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Operator
+         * @generated
+         */
+        public Adapter createOperatorAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Node <em>Node</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Node
+         * @generated
+         */
+        public Adapter createNodeAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Statement <em>Statement</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Statement
+         * @generated
+         */
+        public Adapter createStatementAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.AbstractAssertion <em>Abstract Assertion</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.AbstractAssertion
+         * @generated
+         */
+        public Adapter createAbstractAssertionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.FunctorDefiniton <em>Functor Definiton</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.FunctorDefiniton
+         * @generated
+         */
+        public Adapter createFunctorDefinitonAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition <em>Predicate Definition</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition
+         * @generated
+         */
+        public Adapter createPredicateDefinitionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.FunctionDefinition <em>Function Definition</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.FunctionDefinition
+         * @generated
+         */
+        public Adapter createFunctionDefinitionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Attribute <em>Attribute</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Attribute
+         * @generated
+         */
+        public Adapter createAttributeAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternDeclaration <em>Extern Declaration</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.ExternDeclaration
+         * @generated
+         */
+        public Adapter createExternDeclarationAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternFunctorDeclaration <em>Extern Functor Declaration</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.ExternFunctorDeclaration
+         * @generated
+         */
+        public Adapter createExternFunctorDeclarationAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDeclaration <em>Extern Predicate Declaration</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDeclaration
+         * @generated
+         */
+        public Adapter createExternPredicateDeclarationAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternFunctionDeclaration <em>Extern Function Declaration</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.ExternFunctionDeclaration
+         * @generated
+         */
+        public Adapter createExternFunctionDeclarationAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternAggregationOperatorDeclaration <em>Extern Aggregation Operator Declaration</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.ExternAggregationOperatorDeclaration
+         * @generated
+         */
+        public Adapter createExternAggregationOperatorDeclarationAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternDatatypeDeclaration <em>Extern Datatype Declaration</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.ExternDatatypeDeclaration
+         * @generated
+         */
+        public Adapter createExternDatatypeDeclarationAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassDeclaration <em>Class Declaration</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.ClassDeclaration
+         * @generated
+         */
+        public Adapter createClassDeclarationAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumDeclaration <em>Enum Declaration</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.EnumDeclaration
+         * @generated
+         */
+        public Adapter createEnumDeclarationAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumLiteral <em>Enum Literal</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.EnumLiteral
+         * @generated
+         */
+        public Adapter createEnumLiteralAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Field <em>Field</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Field
+         * @generated
+         */
+        public Adapter createFieldAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Multiplicity <em>Multiplicity</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Multiplicity
+         * @generated
+         */
+        public Adapter createMultiplicityAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultAssertion <em>Default Assertion</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.DefaultAssertion
+         * @generated
+         */
+        public Adapter createDefaultAssertionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Assertion <em>Assertion</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Assertion
+         * @generated
+         */
+        public Adapter createAssertionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.UnboundedMultiplicity <em>Unbounded Multiplicity</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.UnboundedMultiplicity
+         * @generated
+         */
+        public Adapter createUnboundedMultiplicityAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity <em>Exact Multiplicity</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity
+         * @generated
+         */
+        public Adapter createExactMultiplicityAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity <em>Bounded Multiplicity</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity
+         * @generated
+         */
+        public Adapter createBoundedMultiplicityAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.InlinePredicateAttrributes <em>Inline Predicate Attrributes</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.InlinePredicateAttrributes
+         * @generated
+         */
+        public Adapter createInlinePredicateAttrributesAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.AggregationOperator <em>Aggregation Operator</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.AggregationOperator
+         * @generated
+         */
+        public Adapter createAggregationOperatorAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Problem <em>Problem</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Problem
+         * @generated
+         */
+        public Adapter createProblemAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument <em>Typed Star Argument</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument
+         * @generated
+         */
+        public Adapter createTypedStarArgumentAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.TypedVariableArgument <em>Typed Variable Argument</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.TypedVariableArgument
+         * @generated
+         */
+        public Adapter createTypedVariableArgumentAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPredicateDefintion <em>Unnamed Error Predicate Defintion</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPredicateDefintion
+         * @generated
+         */
+        public Adapter createUnnamedErrorPredicateDefintionAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDeclaration <em>Objective Declaration</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDeclaration
+         * @generated
+         */
+        public Adapter createObjectiveDeclarationAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ScopeDeclaration <em>Scope Declaration</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.ScopeDeclaration
+         * @generated
+         */
+        public Adapter createScopeDeclarationAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExactScope <em>Exact Scope</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.ExactScope
+         * @generated
+         */
+        public Adapter createExactScopeAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedScope <em>Bounded Scope</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.BoundedScope
+         * @generated
+         */
+        public Adapter createBoundedScopeAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScope <em>Lower Bounded Scope</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScope
+         * @generated
+         */
+        public Adapter createLowerBoundedScopeAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.NamespaceImport <em>Namespace Import</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.NamespaceImport
+         * @generated
+         */
+        public Adapter createNamespaceImportAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Import <em>Import</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.Import
+         * @generated
+         */
+        public Adapter createImportAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.UriImport <em>Uri Import</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see org.eclipse.viatra.solver.language.solverLanguage.UriImport
+         * @generated
+         */
+        public Adapter createUriImportAdapter() {
+                return null;
+        }
+
+        /**
+         * Creates a new adapter for the default case.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @generated
+         */
+        public Adapter createEObjectAdapter() {
+                return null;
+        }
+
+} //SolverLanguageAdapterFactory