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/LogicproblemAdapterFactory.java | 228 ++++++++++++++++++++ .../logicproblem/util/LogicproblemSwitch.java | 240 +++++++++++++++++++++ 2 files changed, 468 insertions(+) create mode 100644 Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/util/LogicproblemAdapterFactory.java create mode 100644 Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/util/LogicproblemSwitch.java (limited to 'Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/util') diff --git a/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/util/LogicproblemAdapterFactory.java b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/util/LogicproblemAdapterFactory.java new file mode 100644 index 00000000..568a625c --- /dev/null +++ b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/util/LogicproblemAdapterFactory.java @@ -0,0 +1,228 @@ +/** + */ +package hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.util; + +import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.*; + +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.logicproblem.LogicproblemPackage + * @generated + */ +public class LogicproblemAdapterFactory extends AdapterFactoryImpl { + /** + * The cached model package. + * + * + * @generated + */ + protected static LogicproblemPackage modelPackage; + + /** + * Creates an instance of the adapter factory. + * + * + * @generated + */ + public LogicproblemAdapterFactory() { + if (modelPackage == null) { + modelPackage = LogicproblemPackage.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 LogicproblemSwitch modelSwitch = + new LogicproblemSwitch() { + @Override + public Adapter caseLogicProblem(LogicProblem object) { + return createLogicProblemAdapter(); + } + @Override + public Adapter caseContainmentHierarchy(ContainmentHierarchy object) { + return createContainmentHierarchyAdapter(); + } + @Override + public Adapter caseRelationAnnotation(RelationAnnotation object) { + return createRelationAnnotationAdapter(); + } + @Override + public Adapter caseConstantAnnotation(ConstantAnnotation object) { + return createConstantAnnotationAdapter(); + } + @Override + public Adapter caseFunctionAnnotation(FunctionAnnotation object) { + return createFunctionAnnotationAdapter(); + } + @Override + public Adapter caseAssertionAnnotation(AssertionAnnotation object) { + return createAssertionAnnotationAdapter(); + } + @Override + public Adapter caseAnnotation(Annotation object) { + return createAnnotationAdapter(); + } + @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.logicproblem.LogicProblem Logic Problem}'. + * + * 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.logicproblem.LogicProblem + * @generated + */ + public Adapter createLogicProblemAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.ContainmentHierarchy Containment Hierarchy}'. + * + * 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.logicproblem.ContainmentHierarchy + * @generated + */ + public Adapter createContainmentHierarchyAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.RelationAnnotation Relation Annotation}'. + * + * 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.logicproblem.RelationAnnotation + * @generated + */ + public Adapter createRelationAnnotationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.ConstantAnnotation Constant Annotation}'. + * + * 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.logicproblem.ConstantAnnotation + * @generated + */ + public Adapter createConstantAnnotationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.FunctionAnnotation Function Annotation}'. + * + * 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.logicproblem.FunctionAnnotation + * @generated + */ + public Adapter createFunctionAnnotationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.AssertionAnnotation Assertion Annotation}'. + * + * 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.logicproblem.AssertionAnnotation + * @generated + */ + public Adapter createAssertionAnnotationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.Annotation Annotation}'. + * + * 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.logicproblem.Annotation + * @generated + */ + public Adapter createAnnotationAdapter() { + 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; + } + +} //LogicproblemAdapterFactory diff --git a/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/util/LogicproblemSwitch.java b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/util/LogicproblemSwitch.java new file mode 100644 index 00000000..4a79b4a0 --- /dev/null +++ b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/util/LogicproblemSwitch.java @@ -0,0 +1,240 @@ +/** + */ +package hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.util; + +import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.*; + +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.logicproblem.LogicproblemPackage + * @generated + */ +public class LogicproblemSwitch extends Switch { + /** + * The cached model package + * + * + * @generated + */ + protected static LogicproblemPackage modelPackage; + + /** + * Creates an instance of the switch. + * + * + * @generated + */ + public LogicproblemSwitch() { + if (modelPackage == null) { + modelPackage = LogicproblemPackage.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 LogicproblemPackage.LOGIC_PROBLEM: { + LogicProblem logicProblem = (LogicProblem)theEObject; + T result = caseLogicProblem(logicProblem); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogicproblemPackage.CONTAINMENT_HIERARCHY: { + ContainmentHierarchy containmentHierarchy = (ContainmentHierarchy)theEObject; + T result = caseContainmentHierarchy(containmentHierarchy); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogicproblemPackage.RELATION_ANNOTATION: { + RelationAnnotation relationAnnotation = (RelationAnnotation)theEObject; + T result = caseRelationAnnotation(relationAnnotation); + if (result == null) result = caseAnnotation(relationAnnotation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogicproblemPackage.CONSTANT_ANNOTATION: { + ConstantAnnotation constantAnnotation = (ConstantAnnotation)theEObject; + T result = caseConstantAnnotation(constantAnnotation); + if (result == null) result = caseAnnotation(constantAnnotation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogicproblemPackage.FUNCTION_ANNOTATION: { + FunctionAnnotation functionAnnotation = (FunctionAnnotation)theEObject; + T result = caseFunctionAnnotation(functionAnnotation); + if (result == null) result = caseAnnotation(functionAnnotation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogicproblemPackage.ASSERTION_ANNOTATION: { + AssertionAnnotation assertionAnnotation = (AssertionAnnotation)theEObject; + T result = caseAssertionAnnotation(assertionAnnotation); + if (result == null) result = caseAnnotation(assertionAnnotation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case LogicproblemPackage.ANNOTATION: { + Annotation annotation = (Annotation)theEObject; + T result = caseAnnotation(annotation); + if (result == null) result = defaultCase(theEObject); + return result; + } + default: return defaultCase(theEObject); + } + } + + /** + * Returns the result of interpreting the object as an instance of 'Logic Problem'. + * + * 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 'Logic Problem'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseLogicProblem(LogicProblem object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Containment Hierarchy'. + * + * 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 'Containment Hierarchy'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseContainmentHierarchy(ContainmentHierarchy object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Relation Annotation'. + * + * 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 Annotation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseRelationAnnotation(RelationAnnotation object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Constant Annotation'. + * + * 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 Annotation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseConstantAnnotation(ConstantAnnotation object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Function Annotation'. + * + * 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 Annotation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseFunctionAnnotation(FunctionAnnotation object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Assertion Annotation'. + * + * 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 Annotation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseAssertionAnnotation(AssertionAnnotation object) { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Annotation'. + * + * 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 'Annotation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseAnnotation(Annotation 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; + } + +} //LogicproblemSwitch -- cgit v1.2.3-54-g00ecf