1 files changed, 240 insertions, 0 deletions
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;
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Switch</b> for the model's inheritance hierarchy.
+ * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object
+ * and proceeding up the inheritance hierarchy
+ * until a non-null result is returned,
+ * which is the result of the switch.
+ * <!-- end-user-doc -->
+ * @see hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage
+ * @generated
+ */
+public class LogicproblemSwitch<T> extends Switch<T> {
+        /**
+         * The cached model package
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        protected static LogicproblemPackage modelPackage;
+        /**
+         * Creates an instance of the switch.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        public LogicproblemSwitch() {
+                if (modelPackage == null) {
+                        modelPackage = LogicproblemPackage.eINSTANCE;
+                }
+        }
+        /**
+         * Checks whether this is a switch for the given package.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @param ePackage the package in question.
+         * @return whether this is a switch for the given package.
+         * @generated
+         */
+        @Override
+        protected boolean isSwitchFor(EPackage ePackage) {
+                return ePackage == modelPackage;
+        }
+        /**
+         * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @return the first non-null result returned by a <code>caseXXX</code> call.
+         * @generated
+         */
+        @Override
+        protected T doSwitch(int classifierID, EObject theEObject) {
+                switch (classifierID) {
+                        case 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 '<em>Logic Problem</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Logic Problem</em>'.
+         * @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 '<em>Containment Hierarchy</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Containment Hierarchy</em>'.
+         * @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 '<em>Relation Annotation</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Relation Annotation</em>'.
+         * @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 '<em>Constant Annotation</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Constant Annotation</em>'.
+         * @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 '<em>Function Annotation</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Function Annotation</em>'.
+         * @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 '<em>Assertion Annotation</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Assertion Annotation</em>'.
+         * @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 '<em>Annotation</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>Annotation</em>'.
+         * @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 '<em>EObject</em>'.
+         * <!-- begin-user-doc -->
+         * This implementation returns null;
+         * returning a non-null result will terminate the switch, but this is the last case anyway.
+         * <!-- end-user-doc -->
+         * @param object the target of the switch.
+         * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+         * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+         * @generated
+         */
+        @Override
+        public T defaultCase(EObject object) {
+                return null;
+        }
+} //LogicproblemSwitch

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 @@
	1	/**
	2	*/
	3	package hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.util;
	4
	5	import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.*;
	6
	7	import org.eclipse.emf.ecore.EObject;
	8	import org.eclipse.emf.ecore.EPackage;
	9
	10	import org.eclipse.emf.ecore.util.Switch;
	11
	12	/**
	13	* <!-- begin-user-doc -->
	14	* The <b>Switch</b> for the model's inheritance hierarchy.
	15	* It supports the call {@link #doSwitch(EObject) doSwitch(object)}
	16	* to invoke the <code>caseXXX</code> method for each class of the model,
	17	* starting with the actual class of the object
	18	* and proceeding up the inheritance hierarchy
	19	* until a non-null result is returned,
	20	* which is the result of the switch.
	21	* <!-- end-user-doc -->
	22	* @see hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage
	23	* @generated
	24	*/
	25	public class LogicproblemSwitch<T> extends Switch<T> {
	26	/**
	27	* The cached model package
	28	* <!-- begin-user-doc -->
	29	* <!-- end-user-doc -->
	30	* @generated
	31	*/
	32	protected static LogicproblemPackage modelPackage;
	33
	34	/**
	35	* Creates an instance of the switch.
	36	* <!-- begin-user-doc -->
	37	* <!-- end-user-doc -->
	38	* @generated
	39	*/
	40	public LogicproblemSwitch() {
	41	if (modelPackage == null) {
	42	modelPackage = LogicproblemPackage.eINSTANCE;
	43	}
	44	}
	45
	46	/**
	47	* Checks whether this is a switch for the given package.
	48	* <!-- begin-user-doc -->
	49	* <!-- end-user-doc -->
	50	* @param ePackage the package in question.
	51	* @return whether this is a switch for the given package.
	52	* @generated
	53	*/
	54	@Override
	55	protected boolean isSwitchFor(EPackage ePackage) {
	56	return ePackage == modelPackage;
	57	}
	58
	59	/**
	60	* Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
	61	* <!-- begin-user-doc -->
	62	* <!-- end-user-doc -->
	63	* @return the first non-null result returned by a <code>caseXXX</code> call.
	64	* @generated
	65	*/
	66	@Override
	67	protected T doSwitch(int classifierID, EObject theEObject) {
	68	switch (classifierID) {
	69	case LogicproblemPackage.LOGIC_PROBLEM: {
	70	LogicProblem logicProblem = (LogicProblem)theEObject;
	71	T result = caseLogicProblem(logicProblem);
	72	if (result == null) result = defaultCase(theEObject);
	73	return result;
	74	}
	75	case LogicproblemPackage.CONTAINMENT_HIERARCHY: {
	76	ContainmentHierarchy containmentHierarchy = (ContainmentHierarchy)theEObject;
	77	T result = caseContainmentHierarchy(containmentHierarchy);
	78	if (result == null) result = defaultCase(theEObject);
	79	return result;
	80	}
	81	case LogicproblemPackage.RELATION_ANNOTATION: {
	82	RelationAnnotation relationAnnotation = (RelationAnnotation)theEObject;
	83	T result = caseRelationAnnotation(relationAnnotation);
	84	if (result == null) result = caseAnnotation(relationAnnotation);
	85	if (result == null) result = defaultCase(theEObject);
	86	return result;
	87	}
	88	case LogicproblemPackage.CONSTANT_ANNOTATION: {
	89	ConstantAnnotation constantAnnotation = (ConstantAnnotation)theEObject;
	90	T result = caseConstantAnnotation(constantAnnotation);
	91	if (result == null) result = caseAnnotation(constantAnnotation);
	92	if (result == null) result = defaultCase(theEObject);
	93	return result;
	94	}
	95	case LogicproblemPackage.FUNCTION_ANNOTATION: {
	96	FunctionAnnotation functionAnnotation = (FunctionAnnotation)theEObject;
	97	T result = caseFunctionAnnotation(functionAnnotation);
	98	if (result == null) result = caseAnnotation(functionAnnotation);
	99	if (result == null) result = defaultCase(theEObject);
	100	return result;
	101	}
	102	case LogicproblemPackage.ASSERTION_ANNOTATION: {
	103	AssertionAnnotation assertionAnnotation = (AssertionAnnotation)theEObject;
	104	T result = caseAssertionAnnotation(assertionAnnotation);
	105	if (result == null) result = caseAnnotation(assertionAnnotation);
	106	if (result == null) result = defaultCase(theEObject);
	107	return result;
	108	}
	109	case LogicproblemPackage.ANNOTATION: {
	110	Annotation annotation = (Annotation)theEObject;
	111	T result = caseAnnotation(annotation);
	112	if (result == null) result = defaultCase(theEObject);
	113	return result;
	114	}
	115	default: return defaultCase(theEObject);
	116	}
	117	}
	118
	119	/**
	120	* Returns the result of interpreting the object as an instance of '<em>Logic Problem</em>'.
	121	* <!-- begin-user-doc -->
	122	* This implementation returns null;
	123	* returning a non-null result will terminate the switch.
	124	* <!-- end-user-doc -->
	125	* @param object the target of the switch.
	126	* @return the result of interpreting the object as an instance of '<em>Logic Problem</em>'.
	127	* @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	128	* @generated
	129	*/
	130	public T caseLogicProblem(LogicProblem object) {
	131	return null;
	132	}
	133
	134	/**
	135	* Returns the result of interpreting the object as an instance of '<em>Containment Hierarchy</em>'.
	136	* <!-- begin-user-doc -->
	137	* This implementation returns null;
	138	* returning a non-null result will terminate the switch.
	139	* <!-- end-user-doc -->
	140	* @param object the target of the switch.
	141	* @return the result of interpreting the object as an instance of '<em>Containment Hierarchy</em>'.
	142	* @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	143	* @generated
	144	*/
	145	public T caseContainmentHierarchy(ContainmentHierarchy object) {
	146	return null;
	147	}
	148
	149	/**
	150	* Returns the result of interpreting the object as an instance of '<em>Relation Annotation</em>'.
	151	* <!-- begin-user-doc -->
	152	* This implementation returns null;
	153	* returning a non-null result will terminate the switch.
	154	* <!-- end-user-doc -->
	155	* @param object the target of the switch.
	156	* @return the result of interpreting the object as an instance of '<em>Relation Annotation</em>'.
	157	* @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	158	* @generated
	159	*/
	160	public T caseRelationAnnotation(RelationAnnotation object) {
	161	return null;
	162	}
	163
	164	/**
	165	* Returns the result of interpreting the object as an instance of '<em>Constant Annotation</em>'.
	166	* <!-- begin-user-doc -->
	167	* This implementation returns null;
	168	* returning a non-null result will terminate the switch.
	169	* <!-- end-user-doc -->
	170	* @param object the target of the switch.
	171	* @return the result of interpreting the object as an instance of '<em>Constant Annotation</em>'.
	172	* @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	173	* @generated
	174	*/
	175	public T caseConstantAnnotation(ConstantAnnotation object) {
	176	return null;
	177	}
	178
	179	/**
	180	* Returns the result of interpreting the object as an instance of '<em>Function Annotation</em>'.
	181	* <!-- begin-user-doc -->
	182	* This implementation returns null;
	183	* returning a non-null result will terminate the switch.
	184	* <!-- end-user-doc -->
	185	* @param object the target of the switch.
	186	* @return the result of interpreting the object as an instance of '<em>Function Annotation</em>'.
	187	* @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	188	* @generated
	189	*/
	190	public T caseFunctionAnnotation(FunctionAnnotation object) {
	191	return null;
	192	}
	193
	194	/**
	195	* Returns the result of interpreting the object as an instance of '<em>Assertion Annotation</em>'.
	196	* <!-- begin-user-doc -->
	197	* This implementation returns null;
	198	* returning a non-null result will terminate the switch.
	199	* <!-- end-user-doc -->
	200	* @param object the target of the switch.
	201	* @return the result of interpreting the object as an instance of '<em>Assertion Annotation</em>'.
	202	* @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	203	* @generated
	204	*/
	205	public T caseAssertionAnnotation(AssertionAnnotation object) {
	206	return null;
	207	}
	208
	209	/**
	210	* Returns the result of interpreting the object as an instance of '<em>Annotation</em>'.
	211	* <!-- begin-user-doc -->
	212	* This implementation returns null;
	213	* returning a non-null result will terminate the switch.
	214	* <!-- end-user-doc -->
	215	* @param object the target of the switch.
	216	* @return the result of interpreting the object as an instance of '<em>Annotation</em>'.
	217	* @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	218	* @generated
	219	*/
	220	public T caseAnnotation(Annotation object) {
	221	return null;
	222	}
	223
	224	/**
	225	* Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
	226	* <!-- begin-user-doc -->
	227	* This implementation returns null;
	228	* returning a non-null result will terminate the switch, but this is the last case anyway.
	229	* <!-- end-user-doc -->
	230	* @param object the target of the switch.
	231	* @return the result of interpreting the object as an instance of '<em>EObject</em>'.
	232	* @see #doSwitch(org.eclipse.emf.ecore.EObject)
	233	* @generated
	234	*/
	235	@Override
	236	public T defaultCase(EObject object) {
	237	return null;
	238	}
	239
	240	} //LogicproblemSwitch