Migrating Additional projects

author: OszkarSemerath <oszka@152.66.252.189> 2017-06-10 19:05:05 +0200
committer: OszkarSemerath <oszka@152.66.252.189> 2017-06-10 19:05:05 +0200
commit: 60f01f46ba232ed6416054f0a6115cb2a9b70b4e (patch)
tree: 5edf8aeb07abc51f3fec63bbd15c926e1de09552 /Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/util
parent: Initial commit, migrating from SVN (diff)
download: VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.tar.gz
VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.tar.zst
VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.zip
2 files changed, 468 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/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;
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Adapter Factory</b> for the model.
+ * It provides an adapter <code>createXXX</code> method for each class of the model.
+ * <!-- end-user-doc -->
+ * @see hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage
+ * @generated
+ */
+public class LogicproblemAdapterFactory extends AdapterFactoryImpl {
+        /**
+         * The cached model package.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        protected static LogicproblemPackage modelPackage;
+        /**
+         * Creates an instance of the adapter factory.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        public LogicproblemAdapterFactory() {
+                if (modelPackage == null) {
+                        modelPackage = LogicproblemPackage.eINSTANCE;
+                }
+        }
+        /**
+         * Returns whether this factory is applicable for the type of the object.
+         * <!-- begin-user-doc -->
+         * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
+         * <!-- end-user-doc -->
+         * @return whether this factory is applicable for the type of the object.
+         * @generated
+         */
+        @Override
+        public boolean isFactoryForType(Object object) {
+                if (object == modelPackage) {
+                        return true;
+                }
+                if (object instanceof EObject) {
+                        return ((EObject)object).eClass().getEPackage() == modelPackage;
+                }
+                return false;
+        }
+        /**
+         * The switch that delegates to the <code>createXXX</code> methods.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        protected LogicproblemSwitch<Adapter> modelSwitch =
+                new LogicproblemSwitch<Adapter>() {
+                        @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 <code>target</code>.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @param target the object to adapt.
+         * @return the adapter for the <code>target</code>.
+         * @generated
+         */
+        @Override
+        public Adapter createAdapter(Notifier target) {
+                return modelSwitch.doSwitch((EObject)target);
+        }
+        /**
+         * Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem <em>Logic Problem</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see 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 <em>Containment Hierarchy</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see 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 <em>Relation Annotation</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see 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 <em>Constant Annotation</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see 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 <em>Function Annotation</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see 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 <em>Assertion Annotation</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see 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 <em>Annotation</em>}'.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null so that we can easily ignore cases;
+         * it's useful to ignore a case when inheritance will catch all the cases anyway.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @see hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.Annotation
+         * @generated
+         */
+        public Adapter createAnnotationAdapter() {
+                return null;
+        }
+        /**
+         * Creates a new adapter for the default case.
+         * <!-- begin-user-doc -->
+         * This default implementation returns null.
+         * <!-- end-user-doc -->
+         * @return the new adapter.
+         * @generated
+         */
+        public Adapter createEObjectAdapter() {
+                return null;
+        }
+} //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;
+/**
+ * <!-- 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
author	OszkarSemerath <oszka@152.66.252.189>	2017-06-10 19:05:05 +0200
committer	OszkarSemerath <oszka@152.66.252.189>	2017-06-10 19:05:05 +0200
commit	60f01f46ba232ed6416054f0a6115cb2a9b70b4e (patch)
tree	5edf8aeb07abc51f3fec63bbd15c926e1de09552 /Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/util
parent	Initial commit, migrating from SVN (diff)
download	VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.tar.gz VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.tar.zst VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.zip

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 @@
	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.common.notify.Adapter;
	8	import org.eclipse.emf.common.notify.Notifier;
	9
	10	import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
	11
	12	import org.eclipse.emf.ecore.EObject;
	13
	14	/**
	15	* <!-- begin-user-doc -->
	16	* The <b>Adapter Factory</b> for the model.
	17	* It provides an adapter <code>createXXX</code> method for each class of the model.
	18	* <!-- end-user-doc -->
	19	* @see hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage
	20	* @generated
	21	*/
	22	public class LogicproblemAdapterFactory extends AdapterFactoryImpl {
	23	/**
	24	* The cached model package.
	25	* <!-- begin-user-doc -->
	26	* <!-- end-user-doc -->
	27	* @generated
	28	*/
	29	protected static LogicproblemPackage modelPackage;
	30
	31	/**
	32	* Creates an instance of the adapter factory.
	33	* <!-- begin-user-doc -->
	34	* <!-- end-user-doc -->
	35	* @generated
	36	*/
	37	public LogicproblemAdapterFactory() {
	38	if (modelPackage == null) {
	39	modelPackage = LogicproblemPackage.eINSTANCE;
	40	}
	41	}
	42
	43	/**
	44	* Returns whether this factory is applicable for the type of the object.
	45	* <!-- begin-user-doc -->
	46	* This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
	47	* <!-- end-user-doc -->
	48	* @return whether this factory is applicable for the type of the object.
	49	* @generated
	50	*/
	51	@Override
	52	public boolean isFactoryForType(Object object) {
	53	if (object == modelPackage) {
	54	return true;
	55	}
	56	if (object instanceof EObject) {
	57	return ((EObject)object).eClass().getEPackage() == modelPackage;
	58	}
	59	return false;
	60	}
	61
	62	/**
	63	* The switch that delegates to the <code>createXXX</code> methods.
	64	* <!-- begin-user-doc -->
	65	* <!-- end-user-doc -->
	66	* @generated
	67	*/
	68	protected LogicproblemSwitch<Adapter> modelSwitch =
	69	new LogicproblemSwitch<Adapter>() {
	70	@Override
	71	public Adapter caseLogicProblem(LogicProblem object) {
	72	return createLogicProblemAdapter();
	73	}
	74	@Override
	75	public Adapter caseContainmentHierarchy(ContainmentHierarchy object) {
	76	return createContainmentHierarchyAdapter();
	77	}
	78	@Override
	79	public Adapter caseRelationAnnotation(RelationAnnotation object) {
	80	return createRelationAnnotationAdapter();
	81	}
	82	@Override
	83	public Adapter caseConstantAnnotation(ConstantAnnotation object) {
	84	return createConstantAnnotationAdapter();
	85	}
	86	@Override
	87	public Adapter caseFunctionAnnotation(FunctionAnnotation object) {
	88	return createFunctionAnnotationAdapter();
	89	}
	90	@Override
	91	public Adapter caseAssertionAnnotation(AssertionAnnotation object) {
	92	return createAssertionAnnotationAdapter();
	93	}
	94	@Override
	95	public Adapter caseAnnotation(Annotation object) {
	96	return createAnnotationAdapter();
	97	}
	98	@Override
	99	public Adapter defaultCase(EObject object) {
	100	return createEObjectAdapter();
	101	}
	102	};
	103
	104	/**
	105	* Creates an adapter for the <code>target</code>.
	106	* <!-- begin-user-doc -->
	107	* <!-- end-user-doc -->
	108	* @param target the object to adapt.
	109	* @return the adapter for the <code>target</code>.
	110	* @generated
	111	*/
	112	@Override
	113	public Adapter createAdapter(Notifier target) {
	114	return modelSwitch.doSwitch((EObject)target);
	115	}
	116
	117
	118	/**
	119	* Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem <em>Logic Problem</em>}'.
	120	* <!-- begin-user-doc -->
	121	* This default implementation returns null so that we can easily ignore cases;
	122	* it's useful to ignore a case when inheritance will catch all the cases anyway.
	123	* <!-- end-user-doc -->
	124	* @return the new adapter.
	125	* @see hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
	126	* @generated
	127	*/
	128	public Adapter createLogicProblemAdapter() {
	129	return null;
	130	}
	131
	132	/**
	133	* Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.ContainmentHierarchy <em>Containment Hierarchy</em>}'.
	134	* <!-- begin-user-doc -->
	135	* This default implementation returns null so that we can easily ignore cases;
	136	* it's useful to ignore a case when inheritance will catch all the cases anyway.
	137	* <!-- end-user-doc -->
	138	* @return the new adapter.
	139	* @see hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.ContainmentHierarchy
	140	* @generated
	141	*/
	142	public Adapter createContainmentHierarchyAdapter() {
	143	return null;
	144	}
	145
	146	/**
	147	* Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.RelationAnnotation <em>Relation Annotation</em>}'.
	148	* <!-- begin-user-doc -->
	149	* This default implementation returns null so that we can easily ignore cases;
	150	* it's useful to ignore a case when inheritance will catch all the cases anyway.
	151	* <!-- end-user-doc -->
	152	* @return the new adapter.
	153	* @see hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.RelationAnnotation
	154	* @generated
	155	*/
	156	public Adapter createRelationAnnotationAdapter() {
	157	return null;
	158	}
	159
	160	/**
	161	* Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.ConstantAnnotation <em>Constant Annotation</em>}'.
	162	* <!-- begin-user-doc -->
	163	* This default implementation returns null so that we can easily ignore cases;
	164	* it's useful to ignore a case when inheritance will catch all the cases anyway.
	165	* <!-- end-user-doc -->
	166	* @return the new adapter.
	167	* @see hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.ConstantAnnotation
	168	* @generated
	169	*/
	170	public Adapter createConstantAnnotationAdapter() {
	171	return null;
	172	}
	173
	174	/**
	175	* Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.FunctionAnnotation <em>Function Annotation</em>}'.
	176	* <!-- begin-user-doc -->
	177	* This default implementation returns null so that we can easily ignore cases;
	178	* it's useful to ignore a case when inheritance will catch all the cases anyway.
	179	* <!-- end-user-doc -->
	180	* @return the new adapter.
	181	* @see hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.FunctionAnnotation
	182	* @generated
	183	*/
	184	public Adapter createFunctionAnnotationAdapter() {
	185	return null;
	186	}
	187
	188	/**
	189	* Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.AssertionAnnotation <em>Assertion Annotation</em>}'.
	190	* <!-- begin-user-doc -->
	191	* This default implementation returns null so that we can easily ignore cases;
	192	* it's useful to ignore a case when inheritance will catch all the cases anyway.
	193	* <!-- end-user-doc -->
	194	* @return the new adapter.
	195	* @see hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.AssertionAnnotation
	196	* @generated
	197	*/
	198	public Adapter createAssertionAnnotationAdapter() {
	199	return null;
	200	}
	201
	202	/**
	203	* Creates a new adapter for an object of class '{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.Annotation <em>Annotation</em>}'.
	204	* <!-- begin-user-doc -->
	205	* This default implementation returns null so that we can easily ignore cases;
	206	* it's useful to ignore a case when inheritance will catch all the cases anyway.
	207	* <!-- end-user-doc -->
	208	* @return the new adapter.
	209	* @see hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.Annotation
	210	* @generated
	211	*/
	212	public Adapter createAnnotationAdapter() {
	213	return null;
	214	}
	215
	216	/**
	217	* Creates a new adapter for the default case.
	218	* <!-- begin-user-doc -->
	219	* This default implementation returns null.
	220	* <!-- end-user-doc -->
	221	* @return the new adapter.
	222	* @generated
	223	*/
	224	public Adapter createEObjectAdapter() {
	225	return null;
	226	}
	227
	228	} //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 @@
	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