2 files changed, 3734 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
diff --git a/Application/org.eclipse.viatra.solver.language.model/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageSwitch.java b/Application/org.eclipse.viatra.solver.language.model/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageSwitch.java
new file mode 100644
index 00000000..4786bb62
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.model/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageSwitch.java
@@ -0,0 +1,2114 @@
+/**
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.util;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.util.Switch;
+
+import org.eclipse.viatra.solver.language.solverLanguage.*;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Switch</b> for the model's inheritance hierarchy.
+ * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object
+ * and proceeding up the inheritance hierarchy
+ * until a non-null result is returned,
+ * which is the result of the switch.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage
+ * @generated
+ */
+public class SolverLanguageSwitch<T> extends Switch<T> {
+        /**
+         * The cached model package
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        protected static SolverLanguagePackage modelPackage;
+
+        /**
+         * Creates an instance of the switch.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        public SolverLanguageSwitch() {
+                if (modelPackage == null) {
+                        modelPackage = SolverLanguagePackage.eINSTANCE;
+                }
+        }
+
+        /**
+         * Checks whether this is a switch for the given package.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @param ePackage the package in question.
+         * @return whether this is a switch for the given package.
+         * @generated
+         */
+        @Override
+        protected boolean isSwitchFor(EPackage ePackage) {
+                return ePackage == modelPackage;
+        }
+
+        /**
+         * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @return the first non-null result returned by a <code>caseXXX</code> call.
+         * @generated
+         */
+        @Override
+        protected T doSwitch(int classifierID, EObject theEObject) {
+                switch (classifierID) {
+                case SolverLanguagePackage.PATH_COMPONENT: {
+                        PathComponent pathComponent = (PathComponent) theEObject;
+                        T result = casePathComponent(pathComponent);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.SYMBOL: {
+                        Symbol symbol = (Symbol) theEObject;
+                        T result = caseSymbol(symbol);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.CALL: {
+                        Call call = (Call) theEObject;
+                        T result = caseCall(call);
+                        if (result == null)
+                                result = caseExpression(call);
+                        if (result == null)
+                                result = caseStatement(call);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.REFERENCE: {
+                        Reference reference = (Reference) theEObject;
+                        T result = caseReference(reference);
+                        if (result == null)
+                                result = caseExpression(reference);
+                        if (result == null)
+                                result = caseStatement(reference);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.EXPRESSION: {
+                        Expression expression = (Expression) theEObject;
+                        T result = caseExpression(expression);
+                        if (result == null)
+                                result = caseStatement(expression);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.ARGUMENT: {
+                        Argument argument = (Argument) theEObject;
+                        T result = caseArgument(argument);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.ARGUMENT_LIST: {
+                        ArgumentList argumentList = (ArgumentList) theEObject;
+                        T result = caseArgumentList(argumentList);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.EXPRESSION_ARGUMENT: {
+                        ExpressionArgument expressionArgument = (ExpressionArgument) theEObject;
+                        T result = caseExpressionArgument(expressionArgument);
+                        if (result == null)
+                                result = caseArgument(expressionArgument);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.STAR_ARGUMENT: {
+                        StarArgument starArgument = (StarArgument) theEObject;
+                        T result = caseStarArgument(starArgument);
+                        if (result == null)
+                                result = caseArgument(starArgument);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.TYPED_ARGUMENT: {
+                        TypedArgument typedArgument = (TypedArgument) theEObject;
+                        T result = caseTypedArgument(typedArgument);
+                        if (result == null)
+                                result = caseArgument(typedArgument);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.MULTIARY_EXPESSION: {
+                        MultiaryExpession multiaryExpession = (MultiaryExpession) theEObject;
+                        T result = caseMultiaryExpession(multiaryExpession);
+                        if (result == null)
+                                result = caseExpression(multiaryExpession);
+                        if (result == null)
+                                result = caseStatement(multiaryExpession);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.VARIABLE: {
+                        Variable variable = (Variable) theEObject;
+                        T result = caseVariable(variable);
+                        if (result == null)
+                                result = caseSymbol(variable);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.UNARY_EXPRESSION: {
+                        UnaryExpression unaryExpression = (UnaryExpression) theEObject;
+                        T result = caseUnaryExpression(unaryExpression);
+                        if (result == null)
+                                result = caseExpression(unaryExpression);
+                        if (result == null)
+                                result = caseStatement(unaryExpression);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.BINARY_EXPRESSION: {
+                        BinaryExpression binaryExpression = (BinaryExpression) theEObject;
+                        T result = caseBinaryExpression(binaryExpression);
+                        if (result == null)
+                                result = caseExpression(binaryExpression);
+                        if (result == null)
+                                result = caseStatement(binaryExpression);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.DISJUNCTION: {
+                        Disjunction disjunction = (Disjunction) theEObject;
+                        T result = caseDisjunction(disjunction);
+                        if (result == null)
+                                result = caseMultiaryExpession(disjunction);
+                        if (result == null)
+                                result = caseExpression(disjunction);
+                        if (result == null)
+                                result = caseStatement(disjunction);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.CONJUNCTION: {
+                        Conjunction conjunction = (Conjunction) theEObject;
+                        T result = caseConjunction(conjunction);
+                        if (result == null)
+                                result = caseMultiaryExpession(conjunction);
+                        if (result == null)
+                                result = caseExpression(conjunction);
+                        if (result == null)
+                                result = caseStatement(conjunction);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.CONDITIONAL_EXPRESSION: {
+                        ConditionalExpression conditionalExpression = (ConditionalExpression) theEObject;
+                        T result = caseConditionalExpression(conditionalExpression);
+                        if (result == null)
+                                result = caseExpression(conditionalExpression);
+                        if (result == null)
+                                result = caseStatement(conditionalExpression);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.SWITCH: {
+                        org.eclipse.viatra.solver.language.solverLanguage.Switch switch_ = (org.eclipse.viatra.solver.language.solverLanguage.Switch) theEObject;
+                        T result = caseSwitch(switch_);
+                        if (result == null)
+                                result = caseExpression(switch_);
+                        if (result == null)
+                                result = caseStatement(switch_);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.CASE: {
+                        Case case_ = (Case) theEObject;
+                        T result = caseCase(case_);
+                        if (result == null)
+                                result = caseExpression(case_);
+                        if (result == null)
+                                result = caseStatement(case_);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.LET_EXPRESSION: {
+                        LetExpression letExpression = (LetExpression) theEObject;
+                        T result = caseLetExpression(letExpression);
+                        if (result == null)
+                                result = caseExpression(letExpression);
+                        if (result == null)
+                                result = caseStatement(letExpression);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.LET_BINDING: {
+                        LetBinding letBinding = (LetBinding) theEObject;
+                        T result = caseLetBinding(letBinding);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.LITERAL: {
+                        Literal literal = (Literal) theEObject;
+                        T result = caseLiteral(literal);
+                        if (result == null)
+                                result = caseExpression(literal);
+                        if (result == null)
+                                result = caseStatement(literal);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.INT_LITERAL: {
+                        IntLiteral intLiteral = (IntLiteral) theEObject;
+                        T result = caseIntLiteral(intLiteral);
+                        if (result == null)
+                                result = caseLiteral(intLiteral);
+                        if (result == null)
+                                result = caseExpression(intLiteral);
+                        if (result == null)
+                                result = caseStatement(intLiteral);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.REAL_LITERAL: {
+                        RealLiteral realLiteral = (RealLiteral) theEObject;
+                        T result = caseRealLiteral(realLiteral);
+                        if (result == null)
+                                result = caseLiteral(realLiteral);
+                        if (result == null)
+                                result = caseExpression(realLiteral);
+                        if (result == null)
+                                result = caseStatement(realLiteral);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.STRING_LITERAL: {
+                        StringLiteral stringLiteral = (StringLiteral) theEObject;
+                        T result = caseStringLiteral(stringLiteral);
+                        if (result == null)
+                                result = caseLiteral(stringLiteral);
+                        if (result == null)
+                                result = caseExpression(stringLiteral);
+                        if (result == null)
+                                result = caseStatement(stringLiteral);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.LOGIC_LITERAL: {
+                        LogicLiteral logicLiteral = (LogicLiteral) theEObject;
+                        T result = caseLogicLiteral(logicLiteral);
+                        if (result == null)
+                                result = caseLiteral(logicLiteral);
+                        if (result == null)
+                                result = caseExpression(logicLiteral);
+                        if (result == null)
+                                result = caseStatement(logicLiteral);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.EMPTY_LITERAL: {
+                        EmptyLiteral emptyLiteral = (EmptyLiteral) theEObject;
+                        T result = caseEmptyLiteral(emptyLiteral);
+                        if (result == null)
+                                result = caseLiteral(emptyLiteral);
+                        if (result == null)
+                                result = caseExpression(emptyLiteral);
+                        if (result == null)
+                                result = caseStatement(emptyLiteral);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.CAST_EXPRESSION: {
+                        CastExpression castExpression = (CastExpression) theEObject;
+                        T result = caseCastExpression(castExpression);
+                        if (result == null)
+                                result = caseExpression(castExpression);
+                        if (result == null)
+                                result = caseStatement(castExpression);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.AGGREGATE_EXPRESSION: {
+                        AggregateExpression aggregateExpression = (AggregateExpression) theEObject;
+                        T result = caseAggregateExpression(aggregateExpression);
+                        if (result == null)
+                                result = caseExpression(aggregateExpression);
+                        if (result == null)
+                                result = caseStatement(aggregateExpression);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.COUNT: {
+                        Count count = (Count) theEObject;
+                        T result = caseCount(count);
+                        if (result == null)
+                                result = caseAggregateExpression(count);
+                        if (result == null)
+                                result = caseExpression(count);
+                        if (result == null)
+                                result = caseStatement(count);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.AGGREGATION: {
+                        Aggregation aggregation = (Aggregation) theEObject;
+                        T result = caseAggregation(aggregation);
+                        if (result == null)
+                                result = caseAggregateExpression(aggregation);
+                        if (result == null)
+                                result = caseExpression(aggregation);
+                        if (result == null)
+                                result = caseStatement(aggregation);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.FORALL: {
+                        Forall forall = (Forall) theEObject;
+                        T result = caseForall(forall);
+                        if (result == null)
+                                result = caseAggregateExpression(forall);
+                        if (result == null)
+                                result = caseExpression(forall);
+                        if (result == null)
+                                result = caseStatement(forall);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.TYPE_REFERENCE: {
+                        TypeReference typeReference = (TypeReference) theEObject;
+                        T result = caseTypeReference(typeReference);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.INFINITY_LITERAL: {
+                        InfinityLiteral infinityLiteral = (InfinityLiteral) theEObject;
+                        T result = caseInfinityLiteral(infinityLiteral);
+                        if (result == null)
+                                result = caseLiteral(infinityLiteral);
+                        if (result == null)
+                                result = caseExpression(infinityLiteral);
+                        if (result == null)
+                                result = caseStatement(infinityLiteral);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.INTERVAL: {
+                        Interval interval = (Interval) theEObject;
+                        T result = caseInterval(interval);
+                        if (result == null)
+                                result = caseExpression(interval);
+                        if (result == null)
+                                result = caseStatement(interval);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.FUNCTOR: {
+                        Functor functor = (Functor) theEObject;
+                        T result = caseFunctor(functor);
+                        if (result == null)
+                                result = caseSymbol(functor);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.RELATION: {
+                        Relation relation = (Relation) theEObject;
+                        T result = caseRelation(relation);
+                        if (result == null)
+                                result = caseFunctor(relation);
+                        if (result == null)
+                                result = caseSymbol(relation);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.BASE_RELATION: {
+                        BaseRelation baseRelation = (BaseRelation) theEObject;
+                        T result = caseBaseRelation(baseRelation);
+                        if (result == null)
+                                result = caseRelation(baseRelation);
+                        if (result == null)
+                                result = caseFunctor(baseRelation);
+                        if (result == null)
+                                result = caseSymbol(baseRelation);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.PREDICATE: {
+                        Predicate predicate = (Predicate) theEObject;
+                        T result = casePredicate(predicate);
+                        if (result == null)
+                                result = caseRelation(predicate);
+                        if (result == null)
+                                result = caseFunctor(predicate);
+                        if (result == null)
+                                result = caseSymbol(predicate);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.DATATYPE: {
+                        Datatype datatype = (Datatype) theEObject;
+                        T result = caseDatatype(datatype);
+                        if (result == null)
+                                result = caseRelation(datatype);
+                        if (result == null)
+                                result = caseFunctor(datatype);
+                        if (result == null)
+                                result = caseSymbol(datatype);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.FUNCTION: {
+                        Function function = (Function) theEObject;
+                        T result = caseFunction(function);
+                        if (result == null)
+                                result = caseFunctor(function);
+                        if (result == null)
+                                result = caseSymbol(function);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.METRIC: {
+                        Metric metric = (Metric) theEObject;
+                        T result = caseMetric(metric);
+                        if (result == null)
+                                result = caseFunction(metric);
+                        if (result == null)
+                                result = caseFunctor(metric);
+                        if (result == null)
+                                result = caseSymbol(metric);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.OPERATOR: {
+                        Operator operator = (Operator) theEObject;
+                        T result = caseOperator(operator);
+                        if (result == null)
+                                result = caseFunction(operator);
+                        if (result == null)
+                                result = caseFunctor(operator);
+                        if (result == null)
+                                result = caseSymbol(operator);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.NODE: {
+                        Node node = (Node) theEObject;
+                        T result = caseNode(node);
+                        if (result == null)
+                                result = caseSymbol(node);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.STATEMENT: {
+                        Statement statement = (Statement) theEObject;
+                        T result = caseStatement(statement);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.ABSTRACT_ASSERTION: {
+                        AbstractAssertion abstractAssertion = (AbstractAssertion) theEObject;
+                        T result = caseAbstractAssertion(abstractAssertion);
+                        if (result == null)
+                                result = caseStatement(abstractAssertion);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.FUNCTOR_DEFINITON: {
+                        FunctorDefiniton functorDefiniton = (FunctorDefiniton) theEObject;
+                        T result = caseFunctorDefiniton(functorDefiniton);
+                        if (result == null)
+                                result = caseStatement(functorDefiniton);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.PREDICATE_DEFINITION: {
+                        PredicateDefinition predicateDefinition = (PredicateDefinition) theEObject;
+                        T result = casePredicateDefinition(predicateDefinition);
+                        if (result == null)
+                                result = caseFunctorDefiniton(predicateDefinition);
+                        if (result == null)
+                                result = caseInlinePredicateAttrributes(predicateDefinition);
+                        if (result == null)
+                                result = caseStatement(predicateDefinition);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.FUNCTION_DEFINITION: {
+                        FunctionDefinition functionDefinition = (FunctionDefinition) theEObject;
+                        T result = caseFunctionDefinition(functionDefinition);
+                        if (result == null)
+                                result = caseFunctorDefiniton(functionDefinition);
+                        if (result == null)
+                                result = caseStatement(functionDefinition);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.ATTRIBUTE: {
+                        Attribute attribute = (Attribute) theEObject;
+                        T result = caseAttribute(attribute);
+                        if (result == null)
+                                result = caseStatement(attribute);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.EXTERN_DECLARATION: {
+                        ExternDeclaration externDeclaration = (ExternDeclaration) theEObject;
+                        T result = caseExternDeclaration(externDeclaration);
+                        if (result == null)
+                                result = caseStatement(externDeclaration);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.EXTERN_FUNCTOR_DECLARATION: {
+                        ExternFunctorDeclaration externFunctorDeclaration = (ExternFunctorDeclaration) theEObject;
+                        T result = caseExternFunctorDeclaration(externFunctorDeclaration);
+                        if (result == null)
+                                result = caseExternDeclaration(externFunctorDeclaration);
+                        if (result == null)
+                                result = caseStatement(externFunctorDeclaration);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.EXTERN_PREDICATE_DECLARATION: {
+                        ExternPredicateDeclaration externPredicateDeclaration = (ExternPredicateDeclaration) theEObject;
+                        T result = caseExternPredicateDeclaration(externPredicateDeclaration);
+                        if (result == null)
+                                result = caseExternFunctorDeclaration(externPredicateDeclaration);
+                        if (result == null)
+                                result = caseInlinePredicateAttrributes(externPredicateDeclaration);
+                        if (result == null)
+                                result = caseExternDeclaration(externPredicateDeclaration);
+                        if (result == null)
+                                result = caseStatement(externPredicateDeclaration);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.EXTERN_FUNCTION_DECLARATION: {
+                        ExternFunctionDeclaration externFunctionDeclaration = (ExternFunctionDeclaration) theEObject;
+                        T result = caseExternFunctionDeclaration(externFunctionDeclaration);
+                        if (result == null)
+                                result = caseExternFunctorDeclaration(externFunctionDeclaration);
+                        if (result == null)
+                                result = caseExternDeclaration(externFunctionDeclaration);
+                        if (result == null)
+                                result = caseStatement(externFunctionDeclaration);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.EXTERN_AGGREGATION_OPERATOR_DECLARATION: {
+                        ExternAggregationOperatorDeclaration externAggregationOperatorDeclaration = (ExternAggregationOperatorDeclaration) theEObject;
+                        T result = caseExternAggregationOperatorDeclaration(externAggregationOperatorDeclaration);
+                        if (result == null)
+                                result = caseExternDeclaration(externAggregationOperatorDeclaration);
+                        if (result == null)
+                                result = caseStatement(externAggregationOperatorDeclaration);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.EXTERN_DATATYPE_DECLARATION: {
+                        ExternDatatypeDeclaration externDatatypeDeclaration = (ExternDatatypeDeclaration) theEObject;
+                        T result = caseExternDatatypeDeclaration(externDatatypeDeclaration);
+                        if (result == null)
+                                result = caseExternDeclaration(externDatatypeDeclaration);
+                        if (result == null)
+                                result = caseStatement(externDatatypeDeclaration);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.CLASS_DECLARATION: {
+                        ClassDeclaration classDeclaration = (ClassDeclaration) theEObject;
+                        T result = caseClassDeclaration(classDeclaration);
+                        if (result == null)
+                                result = caseStatement(classDeclaration);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.ENUM_DECLARATION: {
+                        EnumDeclaration enumDeclaration = (EnumDeclaration) theEObject;
+                        T result = caseEnumDeclaration(enumDeclaration);
+                        if (result == null)
+                                result = caseStatement(enumDeclaration);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.ENUM_LITERAL: {
+                        EnumLiteral enumLiteral = (EnumLiteral) theEObject;
+                        T result = caseEnumLiteral(enumLiteral);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.FIELD: {
+                        Field field = (Field) theEObject;
+                        T result = caseField(field);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.MULTIPLICITY: {
+                        Multiplicity multiplicity = (Multiplicity) theEObject;
+                        T result = caseMultiplicity(multiplicity);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.DEFAULT_ASSERTION: {
+                        DefaultAssertion defaultAssertion = (DefaultAssertion) theEObject;
+                        T result = caseDefaultAssertion(defaultAssertion);
+                        if (result == null)
+                                result = caseAbstractAssertion(defaultAssertion);
+                        if (result == null)
+                                result = caseStatement(defaultAssertion);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.ASSERTION: {
+                        Assertion assertion = (Assertion) theEObject;
+                        T result = caseAssertion(assertion);
+                        if (result == null)
+                                result = caseAbstractAssertion(assertion);
+                        if (result == null)
+                                result = caseStatement(assertion);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.UNBOUNDED_MULTIPLICITY: {
+                        UnboundedMultiplicity unboundedMultiplicity = (UnboundedMultiplicity) theEObject;
+                        T result = caseUnboundedMultiplicity(unboundedMultiplicity);
+                        if (result == null)
+                                result = caseMultiplicity(unboundedMultiplicity);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.EXACT_MULTIPLICITY: {
+                        ExactMultiplicity exactMultiplicity = (ExactMultiplicity) theEObject;
+                        T result = caseExactMultiplicity(exactMultiplicity);
+                        if (result == null)
+                                result = caseMultiplicity(exactMultiplicity);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.BOUNDED_MULTIPLICITY: {
+                        BoundedMultiplicity boundedMultiplicity = (BoundedMultiplicity) theEObject;
+                        T result = caseBoundedMultiplicity(boundedMultiplicity);
+                        if (result == null)
+                                result = caseMultiplicity(boundedMultiplicity);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.INLINE_PREDICATE_ATTRRIBUTES: {
+                        InlinePredicateAttrributes inlinePredicateAttrributes = (InlinePredicateAttrributes) theEObject;
+                        T result = caseInlinePredicateAttrributes(inlinePredicateAttrributes);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.AGGREGATION_OPERATOR: {
+                        AggregationOperator aggregationOperator = (AggregationOperator) theEObject;
+                        T result = caseAggregationOperator(aggregationOperator);
+                        if (result == null)
+                                result = caseSymbol(aggregationOperator);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.PROBLEM: {
+                        Problem problem = (Problem) theEObject;
+                        T result = caseProblem(problem);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.TYPED_STAR_ARGUMENT: {
+                        TypedStarArgument typedStarArgument = (TypedStarArgument) theEObject;
+                        T result = caseTypedStarArgument(typedStarArgument);
+                        if (result == null)
+                                result = caseTypedArgument(typedStarArgument);
+                        if (result == null)
+                                result = caseArgument(typedStarArgument);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.TYPED_VARIABLE_ARGUMENT: {
+                        TypedVariableArgument typedVariableArgument = (TypedVariableArgument) theEObject;
+                        T result = caseTypedVariableArgument(typedVariableArgument);
+                        if (result == null)
+                                result = caseTypedArgument(typedVariableArgument);
+                        if (result == null)
+                                result = caseArgument(typedVariableArgument);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.UNNAMED_ERROR_PREDICATE_DEFINTION: {
+                        UnnamedErrorPredicateDefintion unnamedErrorPredicateDefintion = (UnnamedErrorPredicateDefintion) theEObject;
+                        T result = caseUnnamedErrorPredicateDefintion(unnamedErrorPredicateDefintion);
+                        if (result == null)
+                                result = caseStatement(unnamedErrorPredicateDefintion);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.OBJECTIVE_DECLARATION: {
+                        ObjectiveDeclaration objectiveDeclaration = (ObjectiveDeclaration) theEObject;
+                        T result = caseObjectiveDeclaration(objectiveDeclaration);
+                        if (result == null)
+                                result = caseStatement(objectiveDeclaration);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.SCOPE_DECLARATION: {
+                        ScopeDeclaration scopeDeclaration = (ScopeDeclaration) theEObject;
+                        T result = caseScopeDeclaration(scopeDeclaration);
+                        if (result == null)
+                                result = caseStatement(scopeDeclaration);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.EXACT_SCOPE: {
+                        ExactScope exactScope = (ExactScope) theEObject;
+                        T result = caseExactScope(exactScope);
+                        if (result == null)
+                                result = caseScopeDeclaration(exactScope);
+                        if (result == null)
+                                result = caseStatement(exactScope);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.BOUNDED_SCOPE: {
+                        BoundedScope boundedScope = (BoundedScope) theEObject;
+                        T result = caseBoundedScope(boundedScope);
+                        if (result == null)
+                                result = caseScopeDeclaration(boundedScope);
+                        if (result == null)
+                                result = caseStatement(boundedScope);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.LOWER_BOUNDED_SCOPE: {
+                        LowerBoundedScope lowerBoundedScope = (LowerBoundedScope) theEObject;
+                        T result = caseLowerBoundedScope(lowerBoundedScope);
+                        if (result == null)
+                                result = caseScopeDeclaration(lowerBoundedScope);
+                        if (result == null)
+                                result = caseStatement(lowerBoundedScope);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.NAMESPACE_IMPORT: {
+                        NamespaceImport namespaceImport = (NamespaceImport) theEObject;
+                        T result = caseNamespaceImport(namespaceImport);
+                        if (result == null)
+                                result = caseImport(namespaceImport);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.IMPORT: {
+                        Import import_ = (Import) theEObject;
+                        T result = caseImport(import_);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                case SolverLanguagePackage.URI_IMPORT: {
+                        UriImport uriImport = (UriImport) theEObject;
+                        T result = caseUriImport(uriImport);
+                        if (result == null)
+                                result = caseImport(uriImport);
+                        if (result == null)
+                                result = defaultCase(theEObject);
+                        return result;
+                }
+                default:
+                        return defaultCase(theEObject);
+                }
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Path Component</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Path Component</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T casePathComponent(PathComponent object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Symbol</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Symbol</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseSymbol(Symbol object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Call</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Call</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseCall(Call object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Reference</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Reference</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseReference(Reference object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Expression</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Expression</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseExpression(Expression object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Argument</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Argument</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseArgument(Argument object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Argument List</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Argument List</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseArgumentList(ArgumentList object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Expression Argument</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Expression Argument</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseExpressionArgument(ExpressionArgument object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Star Argument</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Star Argument</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseStarArgument(StarArgument object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Typed Argument</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Typed Argument</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseTypedArgument(TypedArgument object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Multiary Expession</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Multiary Expession</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseMultiaryExpession(MultiaryExpession object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Variable</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Variable</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseVariable(Variable object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Unary Expression</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Unary Expression</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseUnaryExpression(UnaryExpression object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Binary Expression</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Binary Expression</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseBinaryExpression(BinaryExpression object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Disjunction</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Disjunction</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseDisjunction(Disjunction object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Conjunction</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Conjunction</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseConjunction(Conjunction object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Conditional Expression</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Conditional Expression</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseConditionalExpression(ConditionalExpression object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Switch</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Switch</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseSwitch(org.eclipse.viatra.solver.language.solverLanguage.Switch object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Case</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Case</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseCase(Case object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Let Expression</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Let Expression</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseLetExpression(LetExpression object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Let Binding</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Let Binding</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseLetBinding(LetBinding object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Literal</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Literal</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseLiteral(Literal object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Int Literal</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Int Literal</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseIntLiteral(IntLiteral object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Real Literal</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Real Literal</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseRealLiteral(RealLiteral object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>String Literal</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>String Literal</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseStringLiteral(StringLiteral object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Logic Literal</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Logic Literal</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseLogicLiteral(LogicLiteral object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Empty Literal</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Empty Literal</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseEmptyLiteral(EmptyLiteral object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Cast Expression</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Cast Expression</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseCastExpression(CastExpression object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Aggregate Expression</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Aggregate Expression</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseAggregateExpression(AggregateExpression object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Count</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Count</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseCount(Count object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Aggregation</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Aggregation</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseAggregation(Aggregation object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Forall</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Forall</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseForall(Forall object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Type Reference</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Type Reference</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseTypeReference(TypeReference object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Infinity Literal</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Infinity Literal</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseInfinityLiteral(InfinityLiteral object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Interval</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Interval</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseInterval(Interval object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Functor</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Functor</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseFunctor(Functor object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Relation</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Relation</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseRelation(Relation object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Base Relation</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Base Relation</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseBaseRelation(BaseRelation object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Predicate</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Predicate</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T casePredicate(Predicate object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Datatype</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Datatype</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseDatatype(Datatype object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Function</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Function</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseFunction(Function object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Metric</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Metric</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseMetric(Metric object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Operator</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Operator</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseOperator(Operator object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Node</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Node</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseNode(Node object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Statement</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Statement</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseStatement(Statement object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Abstract Assertion</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Abstract Assertion</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseAbstractAssertion(AbstractAssertion object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Functor Definiton</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Functor Definiton</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseFunctorDefiniton(FunctorDefiniton object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Predicate Definition</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Predicate Definition</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T casePredicateDefinition(PredicateDefinition object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Function Definition</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Function Definition</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseFunctionDefinition(FunctionDefinition object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Attribute</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Attribute</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseAttribute(Attribute object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Extern Declaration</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Extern Declaration</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseExternDeclaration(ExternDeclaration object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Extern Functor Declaration</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Extern Functor Declaration</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseExternFunctorDeclaration(ExternFunctorDeclaration object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Extern Predicate Declaration</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Extern Predicate Declaration</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseExternPredicateDeclaration(ExternPredicateDeclaration object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Extern Function Declaration</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Extern Function Declaration</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseExternFunctionDeclaration(ExternFunctionDeclaration object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Extern Aggregation Operator Declaration</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Extern Aggregation Operator Declaration</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseExternAggregationOperatorDeclaration(ExternAggregationOperatorDeclaration object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Extern Datatype Declaration</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Extern Datatype Declaration</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseExternDatatypeDeclaration(ExternDatatypeDeclaration object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Class Declaration</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Class Declaration</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseClassDeclaration(ClassDeclaration object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Enum Declaration</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Enum Declaration</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseEnumDeclaration(EnumDeclaration object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Enum Literal</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Enum Literal</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseEnumLiteral(EnumLiteral object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Field</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Field</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseField(Field object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Multiplicity</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Multiplicity</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseMultiplicity(Multiplicity object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Default Assertion</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Default Assertion</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseDefaultAssertion(DefaultAssertion object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Assertion</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Assertion</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseAssertion(Assertion object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Unbounded Multiplicity</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Unbounded Multiplicity</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseUnboundedMultiplicity(UnboundedMultiplicity object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Exact Multiplicity</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Exact Multiplicity</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseExactMultiplicity(ExactMultiplicity object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Bounded Multiplicity</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Bounded Multiplicity</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseBoundedMultiplicity(BoundedMultiplicity object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Inline Predicate Attrributes</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Inline Predicate Attrributes</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseInlinePredicateAttrributes(InlinePredicateAttrributes object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Aggregation Operator</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Aggregation Operator</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseAggregationOperator(AggregationOperator object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Problem</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Problem</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseProblem(Problem object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Typed Star Argument</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Typed Star Argument</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseTypedStarArgument(TypedStarArgument object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Typed Variable Argument</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Typed Variable Argument</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseTypedVariableArgument(TypedVariableArgument object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Unnamed Error Predicate Defintion</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Unnamed Error Predicate Defintion</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseUnnamedErrorPredicateDefintion(UnnamedErrorPredicateDefintion object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Objective Declaration</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Objective Declaration</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseObjectiveDeclaration(ObjectiveDeclaration object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Scope Declaration</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Scope Declaration</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseScopeDeclaration(ScopeDeclaration object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Exact Scope</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Exact Scope</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseExactScope(ExactScope object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Bounded Scope</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Bounded Scope</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseBoundedScope(BoundedScope object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Lower Bounded Scope</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Lower Bounded Scope</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseLowerBoundedScope(LowerBoundedScope object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Namespace Import</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Namespace Import</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseNamespaceImport(NamespaceImport object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Import</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Import</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseImport(Import object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>Uri Import</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Uri Import</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+         * @generated
+         */
+        public T caseUriImport(UriImport object) {
+                return null;
+        }
+
+        /**
+         * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch, but this is the last case anyway.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+         * @generated
+         */
+        @Override
+        public T defaultCase(EObject object) {
+                return null;
+        }
+
+} //SolverLanguageSwitch