From 60f01f46ba232ed6416054f0a6115cb2a9b70b4e Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Sat, 10 Jun 2017 19:05:05 +0200 Subject: Migrating Additional projects --- .../util/LogiclanguageAdapterFactory.java | 1092 ++++++++++++++++ .../logiclanguage/util/LogiclanguageSwitch.java | 1374 ++++++++++++++++++++ 2 files changed, 2466 insertions(+) create mode 100644 Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logiclanguage/util/LogiclanguageAdapterFactory.java create mode 100644 Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logiclanguage/util/LogiclanguageSwitch.java (limited to 'Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logiclanguage/util') diff --git a/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logiclanguage/util/LogiclanguageAdapterFactory.java b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logiclanguage/util/LogiclanguageAdapterFactory.java new file mode 100644 index 00000000..a3372dc9 --- /dev/null +++ b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logiclanguage/util/LogiclanguageAdapterFactory.java @@ -0,0 +1,1092 @@ +/** + */ +package hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.util; + +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.*; + +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; + +/** + * + * The Adapter Factory for the model. + * It provides an adapter createXXX method for each class of the model. + * + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguagePackage + * @generated + */ +public class LogiclanguageAdapterFactory extends AdapterFactoryImpl { + /** + * The cached model package. + * + * + * @generated + */ + protected static LogiclanguagePackage modelPackage; + + /** + * Creates an instance of the adapter factory. + * + * + * @generated + */ + public LogiclanguageAdapterFactory() { + if (modelPackage == null) { + modelPackage = LogiclanguagePackage.eINSTANCE; + } + } + + /** + * Returns whether this factory is applicable for the type of the object. + * + * This implementation returns true if the object is either the model's package or is an instance object of the model. + * + * @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 createXXX methods. + * + * + * @generated + */ + protected LogiclanguageSwitch modelSwitch = + new LogiclanguageSwitch() { + @Override + public Adapter caseType(Type object) { + return createTypeAdapter(); + } + @Override + public Adapter caseDefinedElement(DefinedElement object) { + return createDefinedElementAdapter(); + } + @Override + public Adapter caseTypeDefinition(TypeDefinition object) { + return createTypeDefinitionAdapter(); + } + @Override + public Adapter caseTypeReference(TypeReference object) { + return createTypeReferenceAdapter(); + } + @Override + public Adapter caseComplexTypeReference(ComplexTypeReference object) { + return createComplexTypeReferenceAdapter(); + } + @Override + public Adapter casePrimitiveTypeReference(PrimitiveTypeReference object) { + return createPrimitiveTypeReferenceAdapter(); + } + @Override + public Adapter caseIntTypeReference(IntTypeReference object) { + return createIntTypeReferenceAdapter(); + } + @Override + public Adapter caseBoolTypeReference(BoolTypeReference object) { + return createBoolTypeReferenceAdapter(); + } + @Override + public Adapter caseRealTypeReference(RealTypeReference object) { + return createRealTypeReferenceAdapter(); + } + @Override + public Adapter caseFunction(Function object) { + return createFunctionAdapter(); + } + @Override + public Adapter caseTerm(Term object) { + return createTermAdapter(); + } + @Override + public Adapter caseSymbolicDeclaration(SymbolicDeclaration object) { + return createSymbolicDeclarationAdapter(); + } + @Override + public Adapter caseSymbolicValue(SymbolicValue object) { + return createSymbolicValueAdapter(); + } + @Override + public Adapter caseAtomicTerm(AtomicTerm object) { + return createAtomicTermAdapter(); + } + @Override + public Adapter caseIntLiteral(IntLiteral object) { + return createIntLiteralAdapter(); + } + @Override + public Adapter caseBoolLiteral(BoolLiteral object) { + return createBoolLiteralAdapter(); + } + @Override + public Adapter caseRealLiteral(RealLiteral object) { + return createRealLiteralAdapter(); + } + @Override + public Adapter caseVariable(Variable object) { + return createVariableAdapter(); + } + @Override + public Adapter caseQuantifiedExpression(QuantifiedExpression object) { + return createQuantifiedExpressionAdapter(); + } + @Override + public Adapter caseExists(Exists object) { + return createExistsAdapter(); + } + @Override + public Adapter caseForall(Forall object) { + return createForallAdapter(); + } + @Override + public Adapter caseBoolOperation(BoolOperation object) { + return createBoolOperationAdapter(); + } + @Override + public Adapter caseAnd(And object) { + return createAndAdapter(); + } + @Override + public Adapter caseOr(Or object) { + return createOrAdapter(); + } + @Override + public Adapter caseImpl(Impl object) { + return createImplAdapter(); + } + @Override + public Adapter caseNot(Not object) { + return createNotAdapter(); + } + @Override + public Adapter caseIff(Iff object) { + return createIffAdapter(); + } + @Override + public Adapter casePrimitiveRelation(PrimitiveRelation object) { + return createPrimitiveRelationAdapter(); + } + @Override + public Adapter caseEquals(Equals object) { + return createEqualsAdapter(); + } + @Override + public Adapter caseDistinct(Distinct object) { + return createDistinctAdapter(); + } + @Override + public Adapter caseLessThan(LessThan object) { + return createLessThanAdapter(); + } + @Override + public Adapter caseMoreThan(MoreThan object) { + return createMoreThanAdapter(); + } + @Override + public Adapter caseLessOrEqualThan(LessOrEqualThan object) { + return createLessOrEqualThanAdapter(); + } + @Override + public Adapter caseMoreOrEqualThan(MoreOrEqualThan object) { + return createMoreOrEqualThanAdapter(); + } + @Override + public Adapter caseIntOperation(IntOperation object) { + return createIntOperationAdapter(); + } + @Override + public Adapter casePlus(Plus object) { + return createPlusAdapter(); + } + @Override + public Adapter caseMinus(Minus object) { + return createMinusAdapter(); + } + @Override + public Adapter caseMultiply(Multiply object) { + return createMultiplyAdapter(); + } + @Override + public Adapter caseDivison(Divison object) { + return createDivisonAdapter(); + } + @Override + public Adapter caseMod(Mod object) { + return createModAdapter(); + } + @Override + public Adapter caseTypeDescriptor(TypeDescriptor object) { + return createTypeDescriptorAdapter(); + } + @Override + public Adapter caseTermDescription(TermDescription object) { + return createTermDescriptionAdapter(); + } + @Override + public Adapter caseAssertion(Assertion object) { + return createAssertionAdapter(); + } + @Override + public Adapter caseRelation(Relation object) { + return createRelationAdapter(); + } + @Override + public Adapter caseConstant(Constant object) { + return createConstantAdapter(); + } + @Override + public Adapter caseConstantDefinition(ConstantDefinition object) { + return createConstantDefinitionAdapter(); + } + @Override + public Adapter caseRelationDefinition(RelationDefinition object) { + return createRelationDefinitionAdapter(); + } + @Override + public Adapter caseFunctionDefinition(FunctionDefinition object) { + return createFunctionDefinitionAdapter(); + } + @Override + public Adapter caseIfThenElse(IfThenElse object) { + return createIfThenElseAdapter(); + } + @Override + public Adapter caseConstantDeclaration(ConstantDeclaration object) { + return createConstantDeclarationAdapter(); + } + @Override + public Adapter caseRelationDeclaration(RelationDeclaration object) { + return createRelationDeclarationAdapter(); + } + @Override + public Adapter caseFunctionDeclaration(FunctionDeclaration object) { + return createFunctionDeclarationAdapter(); + } + @Override + public Adapter caseTypeDeclaration(TypeDeclaration object) { + return createTypeDeclarationAdapter(); + } + @Override + public Adapter caseUnknownBecauseUninterpreted(UnknownBecauseUninterpreted object) { + return createUnknownBecauseUninterpretedAdapter(); + } + @Override + public Adapter caseInstanceOf(InstanceOf object) { + return createInstanceOfAdapter(); + } + @Override + public Adapter defaultCase(EObject object) { + return createEObjectAdapter(); + } + }; + + /** + * Creates an adapter for the target. + * + * + * @param target the object to adapt. + * @return the adapter for the target. + * @generated + */ + @Override + public Adapter createAdapter(Notifier target) { + return modelSwitch.doSwitch((EObject)target); + } + + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type Type}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type + * @generated + */ + public Adapter createTypeAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement Defined Element}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement + * @generated + */ + public Adapter createDefinedElementAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition Type Definition}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition + * @generated + */ + public Adapter createTypeDefinitionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeReference Type Reference}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeReference + * @generated + */ + public Adapter createTypeReferenceAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference Complex Type Reference}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference + * @generated + */ + public Adapter createComplexTypeReferenceAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.PrimitiveTypeReference Primitive Type Reference}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.PrimitiveTypeReference + * @generated + */ + public Adapter createPrimitiveTypeReferenceAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntTypeReference Int Type Reference}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntTypeReference + * @generated + */ + public Adapter createIntTypeReferenceAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolTypeReference Bool Type Reference}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolTypeReference + * @generated + */ + public Adapter createBoolTypeReferenceAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealTypeReference Real Type Reference}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealTypeReference + * @generated + */ + public Adapter createRealTypeReferenceAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Function Function}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Function + * @generated + */ + public Adapter createFunctionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Term Term}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Term + * @generated + */ + public Adapter createTermAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicDeclaration Symbolic Declaration}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicDeclaration + * @generated + */ + public Adapter createSymbolicDeclarationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicValue Symbolic Value}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicValue + * @generated + */ + public Adapter createSymbolicValueAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.AtomicTerm Atomic Term}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.AtomicTerm + * @generated + */ + public Adapter createAtomicTermAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntLiteral Int Literal}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntLiteral + * @generated + */ + public Adapter createIntLiteralAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolLiteral Bool Literal}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolLiteral + * @generated + */ + public Adapter createBoolLiteralAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealLiteral Real Literal}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealLiteral + * @generated + */ + public Adapter createRealLiteralAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Variable Variable}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Variable + * @generated + */ + public Adapter createVariableAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.QuantifiedExpression Quantified Expression}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.QuantifiedExpression + * @generated + */ + public Adapter createQuantifiedExpressionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Exists Exists}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Exists + * @generated + */ + public Adapter createExistsAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Forall Forall}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Forall + * @generated + */ + public Adapter createForallAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolOperation Bool Operation}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolOperation + * @generated + */ + public Adapter createBoolOperationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.And And}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.And + * @generated + */ + public Adapter createAndAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Or Or}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Or + * @generated + */ + public Adapter createOrAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Impl Impl}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Impl + * @generated + */ + public Adapter createImplAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Not Not}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Not + * @generated + */ + public Adapter createNotAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Iff Iff}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Iff + * @generated + */ + public Adapter createIffAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.PrimitiveRelation Primitive Relation}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.PrimitiveRelation + * @generated + */ + public Adapter createPrimitiveRelationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Equals Equals}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Equals + * @generated + */ + public Adapter createEqualsAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Distinct Distinct}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Distinct + * @generated + */ + public Adapter createDistinctAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LessThan Less Than}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LessThan + * @generated + */ + public Adapter createLessThanAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.MoreThan More Than}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.MoreThan + * @generated + */ + public Adapter createMoreThanAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LessOrEqualThan Less Or Equal Than}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LessOrEqualThan + * @generated + */ + public Adapter createLessOrEqualThanAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.MoreOrEqualThan More Or Equal Than}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.MoreOrEqualThan + * @generated + */ + public Adapter createMoreOrEqualThanAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntOperation Int Operation}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntOperation + * @generated + */ + public Adapter createIntOperationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Plus Plus}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Plus + * @generated + */ + public Adapter createPlusAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Minus Minus}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Minus + * @generated + */ + public Adapter createMinusAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Multiply Multiply}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Multiply + * @generated + */ + public Adapter createMultiplyAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Divison Divison}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Divison + * @generated + */ + public Adapter createDivisonAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Mod Mod}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Mod + * @generated + */ + public Adapter createModAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDescriptor Type Descriptor}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDescriptor + * @generated + */ + public Adapter createTypeDescriptorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TermDescription Term Description}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TermDescription + * @generated + */ + public Adapter createTermDescriptionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Assertion Assertion}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Assertion + * @generated + */ + public Adapter createAssertionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation Relation}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation + * @generated + */ + public Adapter createRelationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Constant Constant}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Constant + * @generated + */ + public Adapter createConstantAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ConstantDefinition Constant Definition}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ConstantDefinition + * @generated + */ + public Adapter createConstantDefinitionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDefinition Relation Definition}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDefinition + * @generated + */ + public Adapter createRelationDefinitionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.FunctionDefinition Function Definition}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.FunctionDefinition + * @generated + */ + public Adapter createFunctionDefinitionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IfThenElse If Then Else}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IfThenElse + * @generated + */ + public Adapter createIfThenElseAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ConstantDeclaration Constant Declaration}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ConstantDeclaration + * @generated + */ + public Adapter createConstantDeclarationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration Relation Declaration}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration + * @generated + */ + public Adapter createRelationDeclarationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.FunctionDeclaration Function Declaration}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.FunctionDeclaration + * @generated + */ + public Adapter createFunctionDeclarationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration Type Declaration}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration + * @generated + */ + public Adapter createTypeDeclarationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.UnknownBecauseUninterpreted Unknown Because Uninterpreted}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.UnknownBecauseUninterpreted + * @generated + */ + public Adapter createUnknownBecauseUninterpretedAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.InstanceOf Instance Of}'. + * + * 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. + * + * @return the new adapter. + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.InstanceOf + * @generated + */ + public Adapter createInstanceOfAdapter() { + return null; + } + + /** + * Creates a new adapter for the default case. + * + * This default implementation returns null. + * + * @return the new adapter. + * @generated + */ + public Adapter createEObjectAdapter() { + return null; + } + +} //LogiclanguageAdapterFactory diff --git a/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logiclanguage/util/LogiclanguageSwitch.java b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logiclanguage/util/LogiclanguageSwitch.java new file mode 100644 index 00000000..a2a1e10a --- /dev/null +++ b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logiclanguage/util/LogiclanguageSwitch.java @@ -0,0 +1,1374 @@ +/** + */ +package hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.util; + +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.*; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EPackage; + +import org.eclipse.emf.ecore.util.Switch; + +/** + * + * The Switch for the model's inheritance hierarchy. + * It supports the call {@link #doSwitch(EObject) doSwitch(object)} + * to invoke the caseXXX 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. + * + * @see hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguagePackage + * @generated + */ +public class LogiclanguageSwitch extends Switch { + /** + * The cached model package + * + * + * @generated + */ + protected static LogiclanguagePackage modelPackage; + + /** + * Creates an instance of the switch. + * + * + * @generated + */ + public LogiclanguageSwitch() { + if (modelPackage == null) { + modelPackage = LogiclanguagePackage.eINSTANCE; + } + } + + /** + * Checks whether this is a switch for the given package. + * + * + * @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 caseXXX for each class of the model until one returns a non null result; it yields that result. + * + * + * @return the first non-null result returned by a caseXXX call. + * @generated + */ + @Override + protected T doSwitch(int classifierID, EObject theEObject) { + switch (classifierID) { + case LogiclanguagePackage.TYPE: { + Type type = (Type)theEObject; + T result = caseType(type); + if (result == null) result = caseTypeDescriptor(type); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.DEFINED_ELEMENT: { + DefinedElement definedElement = (DefinedElement)theEObject; + T result = caseDefinedElement(definedElement); + if (result == null) result = caseSymbolicDeclaration(definedElement); + if (result == null) result = caseTermDescription(definedElement); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.TYPE_DEFINITION: { + TypeDefinition typeDefinition = (TypeDefinition)theEObject; + T result = caseTypeDefinition(typeDefinition); + if (result == null) result = caseType(typeDefinition); + if (result == null) result = caseTypeDescriptor(typeDefinition); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.TYPE_REFERENCE: { + TypeReference typeReference = (TypeReference)theEObject; + T result = caseTypeReference(typeReference); + if (result == null) result = caseTypeDescriptor(typeReference); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.COMPLEX_TYPE_REFERENCE: { + ComplexTypeReference complexTypeReference = (ComplexTypeReference)theEObject; + T result = caseComplexTypeReference(complexTypeReference); + if (result == null) result = caseTypeReference(complexTypeReference); + if (result == null) result = caseTypeDescriptor(complexTypeReference); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.PRIMITIVE_TYPE_REFERENCE: { + PrimitiveTypeReference primitiveTypeReference = (PrimitiveTypeReference)theEObject; + T result = casePrimitiveTypeReference(primitiveTypeReference); + if (result == null) result = caseTypeReference(primitiveTypeReference); + if (result == null) result = caseTypeDescriptor(primitiveTypeReference); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.INT_TYPE_REFERENCE: { + IntTypeReference intTypeReference = (IntTypeReference)theEObject; + T result = caseIntTypeReference(intTypeReference); + if (result == null) result = casePrimitiveTypeReference(intTypeReference); + if (result == null) result = caseTypeReference(intTypeReference); + if (result == null) result = caseTypeDescriptor(intTypeReference); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.BOOL_TYPE_REFERENCE: { + BoolTypeReference boolTypeReference = (BoolTypeReference)theEObject; + T result = caseBoolTypeReference(boolTypeReference); + if (result == null) result = casePrimitiveTypeReference(boolTypeReference); + if (result == null) result = caseTypeReference(boolTypeReference); + if (result == null) result = caseTypeDescriptor(boolTypeReference); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.REAL_TYPE_REFERENCE: { + RealTypeReference realTypeReference = (RealTypeReference)theEObject; + T result = caseRealTypeReference(realTypeReference); + if (result == null) result = casePrimitiveTypeReference(realTypeReference); + if (result == null) result = caseTypeReference(realTypeReference); + if (result == null) result = caseTypeDescriptor(realTypeReference); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.FUNCTION: { + Function function = (Function)theEObject; + T result = caseFunction(function); + if (result == null) result = caseSymbolicDeclaration(function); + if (result == null) result = caseTermDescription(function); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.TERM: { + Term term = (Term)theEObject; + T result = caseTerm(term); + if (result == null) result = caseTermDescription(term); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.SYMBOLIC_DECLARATION: { + SymbolicDeclaration symbolicDeclaration = (SymbolicDeclaration)theEObject; + T result = caseSymbolicDeclaration(symbolicDeclaration); + if (result == null) result = caseTermDescription(symbolicDeclaration); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.SYMBOLIC_VALUE: { + SymbolicValue symbolicValue = (SymbolicValue)theEObject; + T result = caseSymbolicValue(symbolicValue); + if (result == null) result = caseTerm(symbolicValue); + if (result == null) result = caseTermDescription(symbolicValue); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.ATOMIC_TERM: { + AtomicTerm atomicTerm = (AtomicTerm)theEObject; + T result = caseAtomicTerm(atomicTerm); + if (result == null) result = caseTerm(atomicTerm); + if (result == null) result = caseTermDescription(atomicTerm); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.INT_LITERAL: { + IntLiteral intLiteral = (IntLiteral)theEObject; + T result = caseIntLiteral(intLiteral); + if (result == null) result = caseAtomicTerm(intLiteral); + if (result == null) result = caseTerm(intLiteral); + if (result == null) result = caseTermDescription(intLiteral); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.BOOL_LITERAL: { + BoolLiteral boolLiteral = (BoolLiteral)theEObject; + T result = caseBoolLiteral(boolLiteral); + if (result == null) result = caseAtomicTerm(boolLiteral); + if (result == null) result = caseTerm(boolLiteral); + if (result == null) result = caseTermDescription(boolLiteral); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.REAL_LITERAL: { + RealLiteral realLiteral = (RealLiteral)theEObject; + T result = caseRealLiteral(realLiteral); + if (result == null) result = caseAtomicTerm(realLiteral); + if (result == null) result = caseTerm(realLiteral); + if (result == null) result = caseTermDescription(realLiteral); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.VARIABLE: { + Variable variable = (Variable)theEObject; + T result = caseVariable(variable); + if (result == null) result = caseSymbolicDeclaration(variable); + if (result == null) result = caseTermDescription(variable); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.QUANTIFIED_EXPRESSION: { + QuantifiedExpression quantifiedExpression = (QuantifiedExpression)theEObject; + T result = caseQuantifiedExpression(quantifiedExpression); + if (result == null) result = caseTerm(quantifiedExpression); + if (result == null) result = caseTermDescription(quantifiedExpression); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.EXISTS: { + Exists exists = (Exists)theEObject; + T result = caseExists(exists); + if (result == null) result = caseQuantifiedExpression(exists); + if (result == null) result = caseTerm(exists); + if (result == null) result = caseTermDescription(exists); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.FORALL: { + Forall forall = (Forall)theEObject; + T result = caseForall(forall); + if (result == null) result = caseQuantifiedExpression(forall); + if (result == null) result = caseTerm(forall); + if (result == null) result = caseTermDescription(forall); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.BOOL_OPERATION: { + BoolOperation boolOperation = (BoolOperation)theEObject; + T result = caseBoolOperation(boolOperation); + if (result == null) result = caseTerm(boolOperation); + if (result == null) result = caseTermDescription(boolOperation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.AND: { + And and = (And)theEObject; + T result = caseAnd(and); + if (result == null) result = caseBoolOperation(and); + if (result == null) result = caseTerm(and); + if (result == null) result = caseTermDescription(and); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.OR: { + Or or = (Or)theEObject; + T result = caseOr(or); + if (result == null) result = caseBoolOperation(or); + if (result == null) result = caseTerm(or); + if (result == null) result = caseTermDescription(or); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.IMPL: { + Impl impl = (Impl)theEObject; + T result = caseImpl(impl); + if (result == null) result = caseBoolOperation(impl); + if (result == null) result = caseTerm(impl); + if (result == null) result = caseTermDescription(impl); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.NOT: { + Not not = (Not)theEObject; + T result = caseNot(not); + if (result == null) result = caseBoolOperation(not); + if (result == null) result = caseTerm(not); + if (result == null) result = caseTermDescription(not); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.IFF: { + Iff iff = (Iff)theEObject; + T result = caseIff(iff); + if (result == null) result = caseBoolOperation(iff); + if (result == null) result = caseTerm(iff); + if (result == null) result = caseTermDescription(iff); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.PRIMITIVE_RELATION: { + PrimitiveRelation primitiveRelation = (PrimitiveRelation)theEObject; + T result = casePrimitiveRelation(primitiveRelation); + if (result == null) result = caseTerm(primitiveRelation); + if (result == null) result = caseTermDescription(primitiveRelation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.EQUALS: { + Equals equals = (Equals)theEObject; + T result = caseEquals(equals); + if (result == null) result = casePrimitiveRelation(equals); + if (result == null) result = caseTerm(equals); + if (result == null) result = caseTermDescription(equals); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.DISTINCT: { + Distinct distinct = (Distinct)theEObject; + T result = caseDistinct(distinct); + if (result == null) result = casePrimitiveRelation(distinct); + if (result == null) result = caseTerm(distinct); + if (result == null) result = caseTermDescription(distinct); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.LESS_THAN: { + LessThan lessThan = (LessThan)theEObject; + T result = caseLessThan(lessThan); + if (result == null) result = casePrimitiveRelation(lessThan); + if (result == null) result = caseTerm(lessThan); + if (result == null) result = caseTermDescription(lessThan); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.MORE_THAN: { + MoreThan moreThan = (MoreThan)theEObject; + T result = caseMoreThan(moreThan); + if (result == null) result = casePrimitiveRelation(moreThan); + if (result == null) result = caseTerm(moreThan); + if (result == null) result = caseTermDescription(moreThan); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.LESS_OR_EQUAL_THAN: { + LessOrEqualThan lessOrEqualThan = (LessOrEqualThan)theEObject; + T result = caseLessOrEqualThan(lessOrEqualThan); + if (result == null) result = casePrimitiveRelation(lessOrEqualThan); + if (result == null) result = caseTerm(lessOrEqualThan); + if (result == null) result = caseTermDescription(lessOrEqualThan); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.MORE_OR_EQUAL_THAN: { + MoreOrEqualThan moreOrEqualThan = (MoreOrEqualThan)theEObject; + T result = caseMoreOrEqualThan(moreOrEqualThan); + if (result == null) result = casePrimitiveRelation(moreOrEqualThan); + if (result == null) result = caseTerm(moreOrEqualThan); + if (result == null) result = caseTermDescription(moreOrEqualThan); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.INT_OPERATION: { + IntOperation intOperation = (IntOperation)theEObject; + T result = caseIntOperation(intOperation); + if (result == null) result = caseTerm(intOperation); + if (result == null) result = caseTermDescription(intOperation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.PLUS: { + Plus plus = (Plus)theEObject; + T result = casePlus(plus); + if (result == null) result = caseIntOperation(plus); + if (result == null) result = caseTerm(plus); + if (result == null) result = caseTermDescription(plus); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.MINUS: { + Minus minus = (Minus)theEObject; + T result = caseMinus(minus); + if (result == null) result = caseIntOperation(minus); + if (result == null) result = caseTerm(minus); + if (result == null) result = caseTermDescription(minus); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.MULTIPLY: { + Multiply multiply = (Multiply)theEObject; + T result = caseMultiply(multiply); + if (result == null) result = caseIntOperation(multiply); + if (result == null) result = caseTerm(multiply); + if (result == null) result = caseTermDescription(multiply); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.DIVISON: { + Divison divison = (Divison)theEObject; + T result = caseDivison(divison); + if (result == null) result = caseIntOperation(divison); + if (result == null) result = caseTerm(divison); + if (result == null) result = caseTermDescription(divison); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.MOD: { + Mod mod = (Mod)theEObject; + T result = caseMod(mod); + if (result == null) result = caseIntOperation(mod); + if (result == null) result = caseTerm(mod); + if (result == null) result = caseTermDescription(mod); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.TYPE_DESCRIPTOR: { + TypeDescriptor typeDescriptor = (TypeDescriptor)theEObject; + T result = caseTypeDescriptor(typeDescriptor); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.TERM_DESCRIPTION: { + TermDescription termDescription = (TermDescription)theEObject; + T result = caseTermDescription(termDescription); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.ASSERTION: { + Assertion assertion = (Assertion)theEObject; + T result = caseAssertion(assertion); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.RELATION: { + Relation relation = (Relation)theEObject; + T result = caseRelation(relation); + if (result == null) result = caseSymbolicDeclaration(relation); + if (result == null) result = caseTermDescription(relation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.CONSTANT: { + Constant constant = (Constant)theEObject; + T result = caseConstant(constant); + if (result == null) result = caseSymbolicDeclaration(constant); + if (result == null) result = caseTermDescription(constant); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.CONSTANT_DEFINITION: { + ConstantDefinition constantDefinition = (ConstantDefinition)theEObject; + T result = caseConstantDefinition(constantDefinition); + if (result == null) result = caseConstant(constantDefinition); + if (result == null) result = caseSymbolicDeclaration(constantDefinition); + if (result == null) result = caseTermDescription(constantDefinition); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.RELATION_DEFINITION: { + RelationDefinition relationDefinition = (RelationDefinition)theEObject; + T result = caseRelationDefinition(relationDefinition); + if (result == null) result = caseRelation(relationDefinition); + if (result == null) result = caseSymbolicDeclaration(relationDefinition); + if (result == null) result = caseTermDescription(relationDefinition); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.FUNCTION_DEFINITION: { + FunctionDefinition functionDefinition = (FunctionDefinition)theEObject; + T result = caseFunctionDefinition(functionDefinition); + if (result == null) result = caseFunction(functionDefinition); + if (result == null) result = caseSymbolicDeclaration(functionDefinition); + if (result == null) result = caseTermDescription(functionDefinition); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.IF_THEN_ELSE: { + IfThenElse ifThenElse = (IfThenElse)theEObject; + T result = caseIfThenElse(ifThenElse); + if (result == null) result = caseTerm(ifThenElse); + if (result == null) result = caseTermDescription(ifThenElse); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.CONSTANT_DECLARATION: { + ConstantDeclaration constantDeclaration = (ConstantDeclaration)theEObject; + T result = caseConstantDeclaration(constantDeclaration); + if (result == null) result = caseConstant(constantDeclaration); + if (result == null) result = caseSymbolicDeclaration(constantDeclaration); + if (result == null) result = caseTermDescription(constantDeclaration); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.RELATION_DECLARATION: { + RelationDeclaration relationDeclaration = (RelationDeclaration)theEObject; + T result = caseRelationDeclaration(relationDeclaration); + if (result == null) result = caseRelation(relationDeclaration); + if (result == null) result = caseSymbolicDeclaration(relationDeclaration); + if (result == null) result = caseTermDescription(relationDeclaration); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.FUNCTION_DECLARATION: { + FunctionDeclaration functionDeclaration = (FunctionDeclaration)theEObject; + T result = caseFunctionDeclaration(functionDeclaration); + if (result == null) result = caseFunction(functionDeclaration); + if (result == null) result = caseSymbolicDeclaration(functionDeclaration); + if (result == null) result = caseTermDescription(functionDeclaration); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.TYPE_DECLARATION: { + TypeDeclaration typeDeclaration = (TypeDeclaration)theEObject; + T result = caseTypeDeclaration(typeDeclaration); + if (result == null) result = caseType(typeDeclaration); + if (result == null) result = caseTypeDescriptor(typeDeclaration); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.UNKNOWN_BECAUSE_UNINTERPRETED: { + UnknownBecauseUninterpreted unknownBecauseUninterpreted = (UnknownBecauseUninterpreted)theEObject; + T result = caseUnknownBecauseUninterpreted(unknownBecauseUninterpreted); + if (result == null) result = caseTerm(unknownBecauseUninterpreted); + if (result == null) result = caseTermDescription(unknownBecauseUninterpreted); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogiclanguagePackage.INSTANCE_OF: { + InstanceOf instanceOf = (InstanceOf)theEObject; + T result = caseInstanceOf(instanceOf); + if (result == null) result = caseTerm(instanceOf); + if (result == null) result = caseTermDescription(instanceOf); + if (result == null) result = defaultCase(theEObject); + return result; + } + default: return defaultCase(theEObject); + } + } + + /** + * Returns the result of interpreting the object as an instance of 'Type'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Type'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseType(Type object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Defined Element'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Defined Element'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseDefinedElement(DefinedElement object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Type Definition'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Type Definition'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseTypeDefinition(TypeDefinition object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Type Reference'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Type Reference'. + * @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 'Complex Type Reference'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Complex Type Reference'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseComplexTypeReference(ComplexTypeReference object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Primitive Type Reference'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Primitive Type Reference'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T casePrimitiveTypeReference(PrimitiveTypeReference object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Int Type Reference'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Int Type Reference'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseIntTypeReference(IntTypeReference object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Bool Type Reference'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Bool Type Reference'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseBoolTypeReference(BoolTypeReference object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Real Type Reference'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Real Type Reference'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseRealTypeReference(RealTypeReference object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Function'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Function'. + * @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 'Term'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Term'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseTerm(Term object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Symbolic Declaration'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Symbolic Declaration'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseSymbolicDeclaration(SymbolicDeclaration object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Symbolic Value'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Symbolic Value'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseSymbolicValue(SymbolicValue object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Atomic Term'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Atomic Term'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseAtomicTerm(AtomicTerm object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Int Literal'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Int Literal'. + * @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 'Bool Literal'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Bool Literal'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseBoolLiteral(BoolLiteral object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Real Literal'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Real Literal'. + * @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 'Variable'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Variable'. + * @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 'Quantified Expression'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Quantified Expression'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseQuantifiedExpression(QuantifiedExpression object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Exists'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Exists'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseExists(Exists object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Forall'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Forall'. + * @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 'Bool Operation'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Bool Operation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseBoolOperation(BoolOperation object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'And'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'And'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseAnd(And object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Or'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Or'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseOr(Or object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Impl'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Impl'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseImpl(Impl object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Not'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Not'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseNot(Not object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Iff'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Iff'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseIff(Iff object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Primitive Relation'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Primitive Relation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T casePrimitiveRelation(PrimitiveRelation object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Equals'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Equals'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseEquals(Equals object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Distinct'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Distinct'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseDistinct(Distinct object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Less Than'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Less Than'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseLessThan(LessThan object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'More Than'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'More Than'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseMoreThan(MoreThan object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Less Or Equal Than'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Less Or Equal Than'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseLessOrEqualThan(LessOrEqualThan object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'More Or Equal Than'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'More Or Equal Than'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseMoreOrEqualThan(MoreOrEqualThan object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Int Operation'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Int Operation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseIntOperation(IntOperation object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Plus'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Plus'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T casePlus(Plus object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Minus'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Minus'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseMinus(Minus object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Multiply'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Multiply'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseMultiply(Multiply object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Divison'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Divison'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseDivison(Divison object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Mod'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Mod'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseMod(Mod object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Type Descriptor'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Type Descriptor'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseTypeDescriptor(TypeDescriptor object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Term Description'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Term Description'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseTermDescription(TermDescription object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Assertion'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Assertion'. + * @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 'Relation'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Relation'. + * @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 'Constant'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Constant'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseConstant(Constant object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Constant Definition'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Constant Definition'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseConstantDefinition(ConstantDefinition object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Relation Definition'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Relation Definition'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseRelationDefinition(RelationDefinition object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Function Definition'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Function Definition'. + * @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 'If Then Else'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'If Then Else'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseIfThenElse(IfThenElse object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Constant Declaration'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Constant Declaration'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseConstantDeclaration(ConstantDeclaration object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Relation Declaration'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Relation Declaration'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseRelationDeclaration(RelationDeclaration object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Function Declaration'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Function Declaration'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseFunctionDeclaration(FunctionDeclaration object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Type Declaration'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Type Declaration'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseTypeDeclaration(TypeDeclaration object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Unknown Because Uninterpreted'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Unknown Because Uninterpreted'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseUnknownBecauseUninterpreted(UnknownBecauseUninterpreted object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Instance Of'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Instance Of'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseInstanceOf(InstanceOf object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'EObject'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch, but this is the last case anyway. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'EObject'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) + * @generated + */ + @Override + public T defaultCase(EObject object) { + return null; + } + +} //LogiclanguageSwitch -- cgit v1.2.3-70-g09d2