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/PartialinterpretationAdapterFactory.java | 282 +++++++++++++++++++ .../util/PartialinterpretationSwitch.java | 302 +++++++++++++++++++++ 2 files changed, 584 insertions(+) create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/util/PartialinterpretationAdapterFactory.java create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/util/PartialinterpretationSwitch.java (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/util') diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/util/PartialinterpretationAdapterFactory.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/util/PartialinterpretationAdapterFactory.java new file mode 100644 index 00000000..628d56eb --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/util/PartialinterpretationAdapterFactory.java @@ -0,0 +1,282 @@ +/** + */ +package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.util; + +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.*; + +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.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage + * @generated + */ +public class PartialinterpretationAdapterFactory extends AdapterFactoryImpl { + /** + * The cached model package. + * + * + * @generated + */ + protected static PartialinterpretationPackage modelPackage; + + /** + * Creates an instance of the adapter factory. + * + * + * @generated + */ + public PartialinterpretationAdapterFactory() { + if (modelPackage == null) { + modelPackage = PartialinterpretationPackage.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 PartialinterpretationSwitch modelSwitch = + new PartialinterpretationSwitch() { + @Override + public Adapter casePartialInterpretation(PartialInterpretation object) { + return createPartialInterpretationAdapter(); + } + @Override + public Adapter casePartialConstantInterpretation(PartialConstantInterpretation object) { + return createPartialConstantInterpretationAdapter(); + } + @Override + public Adapter casePartialRelationInterpretation(PartialRelationInterpretation object) { + return createPartialRelationInterpretationAdapter(); + } + @Override + public Adapter casePartialFunctionInterpretation(PartialFunctionInterpretation object) { + return createPartialFunctionInterpretationAdapter(); + } + @Override + public Adapter casePartialTypeInterpratation(PartialTypeInterpratation object) { + return createPartialTypeInterpratationAdapter(); + } + @Override + public Adapter caseRelationLink(RelationLink object) { + return createRelationLinkAdapter(); + } + @Override + public Adapter caseUnaryElementRelationLink(UnaryElementRelationLink object) { + return createUnaryElementRelationLinkAdapter(); + } + @Override + public Adapter caseBinaryElementRelationLink(BinaryElementRelationLink object) { + return createBinaryElementRelationLinkAdapter(); + } + @Override + public Adapter caseNaryRelationLink(NaryRelationLink object) { + return createNaryRelationLinkAdapter(); + } + @Override + public Adapter caseNaryRelationLinkElement(NaryRelationLinkElement object) { + return createNaryRelationLinkElementAdapter(); + } + @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.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation Partial Interpretation}'. + * + * 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.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation + * @generated + */ + public Adapter createPartialInterpretationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialConstantInterpretation Partial Constant Interpretation}'. + * + * 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.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialConstantInterpretation + * @generated + */ + public Adapter createPartialConstantInterpretationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation Partial Relation Interpretation}'. + * + * 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.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation + * @generated + */ + public Adapter createPartialRelationInterpretationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialFunctionInterpretation Partial Function Interpretation}'. + * + * 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.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialFunctionInterpretation + * @generated + */ + public Adapter createPartialFunctionInterpretationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation Partial Type Interpratation}'. + * + * 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.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation + * @generated + */ + public Adapter createPartialTypeInterpratationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.RelationLink Relation Link}'. + * + * 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.viatrasolver.partialinterpretationlanguage.partialinterpretation.RelationLink + * @generated + */ + public Adapter createRelationLinkAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.UnaryElementRelationLink Unary Element Relation Link}'. + * + * 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.viatrasolver.partialinterpretationlanguage.partialinterpretation.UnaryElementRelationLink + * @generated + */ + public Adapter createUnaryElementRelationLinkAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink Binary Element Relation Link}'. + * + * 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.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink + * @generated + */ + public Adapter createBinaryElementRelationLinkAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.NaryRelationLink Nary Relation Link}'. + * + * 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.viatrasolver.partialinterpretationlanguage.partialinterpretation.NaryRelationLink + * @generated + */ + public Adapter createNaryRelationLinkAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.NaryRelationLinkElement Nary Relation Link 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.viatrasolver.partialinterpretationlanguage.partialinterpretation.NaryRelationLinkElement + * @generated + */ + public Adapter createNaryRelationLinkElementAdapter() { + 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; + } + +} //PartialinterpretationAdapterFactory diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/util/PartialinterpretationSwitch.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/util/PartialinterpretationSwitch.java new file mode 100644 index 00000000..f99b2d76 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/util/PartialinterpretationSwitch.java @@ -0,0 +1,302 @@ +/** + */ +package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.util; + +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.*; + +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.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage + * @generated + */ +public class PartialinterpretationSwitch extends Switch { + /** + * The cached model package + * + * + * @generated + */ + protected static PartialinterpretationPackage modelPackage; + + /** + * Creates an instance of the switch. + * + * + * @generated + */ + public PartialinterpretationSwitch() { + if (modelPackage == null) { + modelPackage = PartialinterpretationPackage.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 PartialinterpretationPackage.PARTIAL_INTERPRETATION: { + PartialInterpretation partialInterpretation = (PartialInterpretation)theEObject; + T result = casePartialInterpretation(partialInterpretation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case PartialinterpretationPackage.PARTIAL_CONSTANT_INTERPRETATION: { + PartialConstantInterpretation partialConstantInterpretation = (PartialConstantInterpretation)theEObject; + T result = casePartialConstantInterpretation(partialConstantInterpretation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case PartialinterpretationPackage.PARTIAL_RELATION_INTERPRETATION: { + PartialRelationInterpretation partialRelationInterpretation = (PartialRelationInterpretation)theEObject; + T result = casePartialRelationInterpretation(partialRelationInterpretation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case PartialinterpretationPackage.PARTIAL_FUNCTION_INTERPRETATION: { + PartialFunctionInterpretation partialFunctionInterpretation = (PartialFunctionInterpretation)theEObject; + T result = casePartialFunctionInterpretation(partialFunctionInterpretation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case PartialinterpretationPackage.PARTIAL_TYPE_INTERPRATATION: { + PartialTypeInterpratation partialTypeInterpratation = (PartialTypeInterpratation)theEObject; + T result = casePartialTypeInterpratation(partialTypeInterpratation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case PartialinterpretationPackage.RELATION_LINK: { + RelationLink relationLink = (RelationLink)theEObject; + T result = caseRelationLink(relationLink); + if (result == null) result = defaultCase(theEObject); + return result; + } + case PartialinterpretationPackage.UNARY_ELEMENT_RELATION_LINK: { + UnaryElementRelationLink unaryElementRelationLink = (UnaryElementRelationLink)theEObject; + T result = caseUnaryElementRelationLink(unaryElementRelationLink); + if (result == null) result = caseRelationLink(unaryElementRelationLink); + if (result == null) result = defaultCase(theEObject); + return result; + } + case PartialinterpretationPackage.BINARY_ELEMENT_RELATION_LINK: { + BinaryElementRelationLink binaryElementRelationLink = (BinaryElementRelationLink)theEObject; + T result = caseBinaryElementRelationLink(binaryElementRelationLink); + if (result == null) result = caseRelationLink(binaryElementRelationLink); + if (result == null) result = defaultCase(theEObject); + return result; + } + case PartialinterpretationPackage.NARY_RELATION_LINK: { + NaryRelationLink naryRelationLink = (NaryRelationLink)theEObject; + T result = caseNaryRelationLink(naryRelationLink); + if (result == null) result = caseRelationLink(naryRelationLink); + if (result == null) result = defaultCase(theEObject); + return result; + } + case PartialinterpretationPackage.NARY_RELATION_LINK_ELEMENT: { + NaryRelationLinkElement naryRelationLinkElement = (NaryRelationLinkElement)theEObject; + T result = caseNaryRelationLinkElement(naryRelationLinkElement); + if (result == null) result = defaultCase(theEObject); + return result; + } + default: return defaultCase(theEObject); + } + } + + /** + * Returns the result of interpreting the object as an instance of 'Partial Interpretation'. + * + * 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 'Partial Interpretation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T casePartialInterpretation(PartialInterpretation object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Partial Constant Interpretation'. + * + * 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 'Partial Constant Interpretation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T casePartialConstantInterpretation(PartialConstantInterpretation object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Partial Relation Interpretation'. + * + * 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 'Partial Relation Interpretation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T casePartialRelationInterpretation(PartialRelationInterpretation object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Partial Function Interpretation'. + * + * 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 'Partial Function Interpretation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T casePartialFunctionInterpretation(PartialFunctionInterpretation object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Partial Type Interpratation'. + * + * 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 'Partial Type Interpratation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T casePartialTypeInterpratation(PartialTypeInterpratation object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Relation Link'. + * + * 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 Link'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseRelationLink(RelationLink object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Unary Element Relation Link'. + * + * 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 'Unary Element Relation Link'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseUnaryElementRelationLink(UnaryElementRelationLink object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Binary Element Relation Link'. + * + * 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 'Binary Element Relation Link'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseBinaryElementRelationLink(BinaryElementRelationLink object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Nary Relation Link'. + * + * 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 'Nary Relation Link'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseNaryRelationLink(NaryRelationLink object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Nary Relation Link 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 'Nary Relation Link Element'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseNaryRelationLinkElement(NaryRelationLinkElement 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; + } + +} //PartialinterpretationSwitch -- cgit v1.2.3-54-g00ecf