diff options
Diffstat (limited to 'Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/impl/LogicProblemImpl.java')
-rw-r--r-- | Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/impl/LogicProblemImpl.java | 411 |
1 files changed, 411 insertions, 0 deletions
diff --git a/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/impl/LogicProblemImpl.java b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/impl/LogicProblemImpl.java new file mode 100644 index 00000000..70b31163 --- /dev/null +++ b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logicproblem/impl/LogicProblemImpl.java | |||
@@ -0,0 +1,411 @@ | |||
1 | /** | ||
2 | */ | ||
3 | package hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.impl; | ||
4 | |||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Assertion; | ||
6 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Constant; | ||
7 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement; | ||
8 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Function; | ||
9 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation; | ||
10 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type; | ||
11 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.Annotation; | ||
12 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.ContainmentHierarchy; | ||
13 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem; | ||
14 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage; | ||
15 | |||
16 | import java.util.Collection; | ||
17 | |||
18 | import org.eclipse.emf.common.notify.NotificationChain; | ||
19 | |||
20 | import org.eclipse.emf.common.util.EList; | ||
21 | |||
22 | import org.eclipse.emf.ecore.EClass; | ||
23 | import org.eclipse.emf.ecore.InternalEObject; | ||
24 | |||
25 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; | ||
26 | |||
27 | import org.eclipse.emf.ecore.util.EObjectContainmentEList; | ||
28 | import org.eclipse.emf.ecore.util.InternalEList; | ||
29 | |||
30 | /** | ||
31 | * <!-- begin-user-doc --> | ||
32 | * An implementation of the model object '<em><b>Logic Problem</b></em>'. | ||
33 | * <!-- end-user-doc --> | ||
34 | * <p> | ||
35 | * The following features are implemented: | ||
36 | * </p> | ||
37 | * <ul> | ||
38 | * <li>{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.impl.LogicProblemImpl#getTypes <em>Types</em>}</li> | ||
39 | * <li>{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.impl.LogicProblemImpl#getFunctions <em>Functions</em>}</li> | ||
40 | * <li>{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.impl.LogicProblemImpl#getAssertions <em>Assertions</em>}</li> | ||
41 | * <li>{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.impl.LogicProblemImpl#getRelations <em>Relations</em>}</li> | ||
42 | * <li>{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.impl.LogicProblemImpl#getConstants <em>Constants</em>}</li> | ||
43 | * <li>{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.impl.LogicProblemImpl#getElements <em>Elements</em>}</li> | ||
44 | * <li>{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.impl.LogicProblemImpl#getContainmentHierarchies <em>Containment Hierarchies</em>}</li> | ||
45 | * <li>{@link hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.impl.LogicProblemImpl#getAnnotations <em>Annotations</em>}</li> | ||
46 | * </ul> | ||
47 | * | ||
48 | * @generated | ||
49 | */ | ||
50 | public class LogicProblemImpl extends MinimalEObjectImpl.Container implements LogicProblem { | ||
51 | /** | ||
52 | * The cached value of the '{@link #getTypes() <em>Types</em>}' containment reference list. | ||
53 | * <!-- begin-user-doc --> | ||
54 | * <!-- end-user-doc --> | ||
55 | * @see #getTypes() | ||
56 | * @generated | ||
57 | * @ordered | ||
58 | */ | ||
59 | protected EList<Type> types; | ||
60 | |||
61 | /** | ||
62 | * The cached value of the '{@link #getFunctions() <em>Functions</em>}' containment reference list. | ||
63 | * <!-- begin-user-doc --> | ||
64 | * <!-- end-user-doc --> | ||
65 | * @see #getFunctions() | ||
66 | * @generated | ||
67 | * @ordered | ||
68 | */ | ||
69 | protected EList<Function> functions; | ||
70 | |||
71 | /** | ||
72 | * The cached value of the '{@link #getAssertions() <em>Assertions</em>}' containment reference list. | ||
73 | * <!-- begin-user-doc --> | ||
74 | * <!-- end-user-doc --> | ||
75 | * @see #getAssertions() | ||
76 | * @generated | ||
77 | * @ordered | ||
78 | */ | ||
79 | protected EList<Assertion> assertions; | ||
80 | |||
81 | /** | ||
82 | * The cached value of the '{@link #getRelations() <em>Relations</em>}' containment reference list. | ||
83 | * <!-- begin-user-doc --> | ||
84 | * <!-- end-user-doc --> | ||
85 | * @see #getRelations() | ||
86 | * @generated | ||
87 | * @ordered | ||
88 | */ | ||
89 | protected EList<Relation> relations; | ||
90 | |||
91 | /** | ||
92 | * The cached value of the '{@link #getConstants() <em>Constants</em>}' containment reference list. | ||
93 | * <!-- begin-user-doc --> | ||
94 | * <!-- end-user-doc --> | ||
95 | * @see #getConstants() | ||
96 | * @generated | ||
97 | * @ordered | ||
98 | */ | ||
99 | protected EList<Constant> constants; | ||
100 | |||
101 | /** | ||
102 | * The cached value of the '{@link #getElements() <em>Elements</em>}' containment reference list. | ||
103 | * <!-- begin-user-doc --> | ||
104 | * <!-- end-user-doc --> | ||
105 | * @see #getElements() | ||
106 | * @generated | ||
107 | * @ordered | ||
108 | */ | ||
109 | protected EList<DefinedElement> elements; | ||
110 | |||
111 | /** | ||
112 | * The cached value of the '{@link #getContainmentHierarchies() <em>Containment Hierarchies</em>}' containment reference list. | ||
113 | * <!-- begin-user-doc --> | ||
114 | * <!-- end-user-doc --> | ||
115 | * @see #getContainmentHierarchies() | ||
116 | * @generated | ||
117 | * @ordered | ||
118 | */ | ||
119 | protected EList<ContainmentHierarchy> containmentHierarchies; | ||
120 | |||
121 | /** | ||
122 | * The cached value of the '{@link #getAnnotations() <em>Annotations</em>}' containment reference list. | ||
123 | * <!-- begin-user-doc --> | ||
124 | * <!-- end-user-doc --> | ||
125 | * @see #getAnnotations() | ||
126 | * @generated | ||
127 | * @ordered | ||
128 | */ | ||
129 | protected EList<Annotation> annotations; | ||
130 | |||
131 | /** | ||
132 | * <!-- begin-user-doc --> | ||
133 | * <!-- end-user-doc --> | ||
134 | * @generated | ||
135 | */ | ||
136 | protected LogicProblemImpl() { | ||
137 | super(); | ||
138 | } | ||
139 | |||
140 | /** | ||
141 | * <!-- begin-user-doc --> | ||
142 | * <!-- end-user-doc --> | ||
143 | * @generated | ||
144 | */ | ||
145 | @Override | ||
146 | protected EClass eStaticClass() { | ||
147 | return LogicproblemPackage.Literals.LOGIC_PROBLEM; | ||
148 | } | ||
149 | |||
150 | /** | ||
151 | * <!-- begin-user-doc --> | ||
152 | * <!-- end-user-doc --> | ||
153 | * @generated | ||
154 | */ | ||
155 | public EList<Type> getTypes() { | ||
156 | if (types == null) { | ||
157 | types = new EObjectContainmentEList<Type>(Type.class, this, LogicproblemPackage.LOGIC_PROBLEM__TYPES); | ||
158 | } | ||
159 | return types; | ||
160 | } | ||
161 | |||
162 | /** | ||
163 | * <!-- begin-user-doc --> | ||
164 | * <!-- end-user-doc --> | ||
165 | * @generated | ||
166 | */ | ||
167 | public EList<Function> getFunctions() { | ||
168 | if (functions == null) { | ||
169 | functions = new EObjectContainmentEList<Function>(Function.class, this, LogicproblemPackage.LOGIC_PROBLEM__FUNCTIONS); | ||
170 | } | ||
171 | return functions; | ||
172 | } | ||
173 | |||
174 | /** | ||
175 | * <!-- begin-user-doc --> | ||
176 | * <!-- end-user-doc --> | ||
177 | * @generated | ||
178 | */ | ||
179 | public EList<Assertion> getAssertions() { | ||
180 | if (assertions == null) { | ||
181 | assertions = new EObjectContainmentEList<Assertion>(Assertion.class, this, LogicproblemPackage.LOGIC_PROBLEM__ASSERTIONS); | ||
182 | } | ||
183 | return assertions; | ||
184 | } | ||
185 | |||
186 | /** | ||
187 | * <!-- begin-user-doc --> | ||
188 | * <!-- end-user-doc --> | ||
189 | * @generated | ||
190 | */ | ||
191 | public EList<Relation> getRelations() { | ||
192 | if (relations == null) { | ||
193 | relations = new EObjectContainmentEList<Relation>(Relation.class, this, LogicproblemPackage.LOGIC_PROBLEM__RELATIONS); | ||
194 | } | ||
195 | return relations; | ||
196 | } | ||
197 | |||
198 | /** | ||
199 | * <!-- begin-user-doc --> | ||
200 | * <!-- end-user-doc --> | ||
201 | * @generated | ||
202 | */ | ||
203 | public EList<Constant> getConstants() { | ||
204 | if (constants == null) { | ||
205 | constants = new EObjectContainmentEList<Constant>(Constant.class, this, LogicproblemPackage.LOGIC_PROBLEM__CONSTANTS); | ||
206 | } | ||
207 | return constants; | ||
208 | } | ||
209 | |||
210 | /** | ||
211 | * <!-- begin-user-doc --> | ||
212 | * <!-- end-user-doc --> | ||
213 | * @generated | ||
214 | */ | ||
215 | public EList<DefinedElement> getElements() { | ||
216 | if (elements == null) { | ||
217 | elements = new EObjectContainmentEList<DefinedElement>(DefinedElement.class, this, LogicproblemPackage.LOGIC_PROBLEM__ELEMENTS); | ||
218 | } | ||
219 | return elements; | ||
220 | } | ||
221 | |||
222 | /** | ||
223 | * <!-- begin-user-doc --> | ||
224 | * <!-- end-user-doc --> | ||
225 | * @generated | ||
226 | */ | ||
227 | public EList<ContainmentHierarchy> getContainmentHierarchies() { | ||
228 | if (containmentHierarchies == null) { | ||
229 | containmentHierarchies = new EObjectContainmentEList<ContainmentHierarchy>(ContainmentHierarchy.class, this, LogicproblemPackage.LOGIC_PROBLEM__CONTAINMENT_HIERARCHIES); | ||
230 | } | ||
231 | return containmentHierarchies; | ||
232 | } | ||
233 | |||
234 | /** | ||
235 | * <!-- begin-user-doc --> | ||
236 | * <!-- end-user-doc --> | ||
237 | * @generated | ||
238 | */ | ||
239 | public EList<Annotation> getAnnotations() { | ||
240 | if (annotations == null) { | ||
241 | annotations = new EObjectContainmentEList<Annotation>(Annotation.class, this, LogicproblemPackage.LOGIC_PROBLEM__ANNOTATIONS); | ||
242 | } | ||
243 | return annotations; | ||
244 | } | ||
245 | |||
246 | /** | ||
247 | * <!-- begin-user-doc --> | ||
248 | * <!-- end-user-doc --> | ||
249 | * @generated | ||
250 | */ | ||
251 | @Override | ||
252 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) { | ||
253 | switch (featureID) { | ||
254 | case LogicproblemPackage.LOGIC_PROBLEM__TYPES: | ||
255 | return ((InternalEList<?>)getTypes()).basicRemove(otherEnd, msgs); | ||
256 | case LogicproblemPackage.LOGIC_PROBLEM__FUNCTIONS: | ||
257 | return ((InternalEList<?>)getFunctions()).basicRemove(otherEnd, msgs); | ||
258 | case LogicproblemPackage.LOGIC_PROBLEM__ASSERTIONS: | ||
259 | return ((InternalEList<?>)getAssertions()).basicRemove(otherEnd, msgs); | ||
260 | case LogicproblemPackage.LOGIC_PROBLEM__RELATIONS: | ||
261 | return ((InternalEList<?>)getRelations()).basicRemove(otherEnd, msgs); | ||
262 | case LogicproblemPackage.LOGIC_PROBLEM__CONSTANTS: | ||
263 | return ((InternalEList<?>)getConstants()).basicRemove(otherEnd, msgs); | ||
264 | case LogicproblemPackage.LOGIC_PROBLEM__ELEMENTS: | ||
265 | return ((InternalEList<?>)getElements()).basicRemove(otherEnd, msgs); | ||
266 | case LogicproblemPackage.LOGIC_PROBLEM__CONTAINMENT_HIERARCHIES: | ||
267 | return ((InternalEList<?>)getContainmentHierarchies()).basicRemove(otherEnd, msgs); | ||
268 | case LogicproblemPackage.LOGIC_PROBLEM__ANNOTATIONS: | ||
269 | return ((InternalEList<?>)getAnnotations()).basicRemove(otherEnd, msgs); | ||
270 | } | ||
271 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
272 | } | ||
273 | |||
274 | /** | ||
275 | * <!-- begin-user-doc --> | ||
276 | * <!-- end-user-doc --> | ||
277 | * @generated | ||
278 | */ | ||
279 | @Override | ||
280 | public Object eGet(int featureID, boolean resolve, boolean coreType) { | ||
281 | switch (featureID) { | ||
282 | case LogicproblemPackage.LOGIC_PROBLEM__TYPES: | ||
283 | return getTypes(); | ||
284 | case LogicproblemPackage.LOGIC_PROBLEM__FUNCTIONS: | ||
285 | return getFunctions(); | ||
286 | case LogicproblemPackage.LOGIC_PROBLEM__ASSERTIONS: | ||
287 | return getAssertions(); | ||
288 | case LogicproblemPackage.LOGIC_PROBLEM__RELATIONS: | ||
289 | return getRelations(); | ||
290 | case LogicproblemPackage.LOGIC_PROBLEM__CONSTANTS: | ||
291 | return getConstants(); | ||
292 | case LogicproblemPackage.LOGIC_PROBLEM__ELEMENTS: | ||
293 | return getElements(); | ||
294 | case LogicproblemPackage.LOGIC_PROBLEM__CONTAINMENT_HIERARCHIES: | ||
295 | return getContainmentHierarchies(); | ||
296 | case LogicproblemPackage.LOGIC_PROBLEM__ANNOTATIONS: | ||
297 | return getAnnotations(); | ||
298 | } | ||
299 | return super.eGet(featureID, resolve, coreType); | ||
300 | } | ||
301 | |||
302 | /** | ||
303 | * <!-- begin-user-doc --> | ||
304 | * <!-- end-user-doc --> | ||
305 | * @generated | ||
306 | */ | ||
307 | @SuppressWarnings("unchecked") | ||
308 | @Override | ||
309 | public void eSet(int featureID, Object newValue) { | ||
310 | switch (featureID) { | ||
311 | case LogicproblemPackage.LOGIC_PROBLEM__TYPES: | ||
312 | getTypes().clear(); | ||
313 | getTypes().addAll((Collection<? extends Type>)newValue); | ||
314 | return; | ||
315 | case LogicproblemPackage.LOGIC_PROBLEM__FUNCTIONS: | ||
316 | getFunctions().clear(); | ||
317 | getFunctions().addAll((Collection<? extends Function>)newValue); | ||
318 | return; | ||
319 | case LogicproblemPackage.LOGIC_PROBLEM__ASSERTIONS: | ||
320 | getAssertions().clear(); | ||
321 | getAssertions().addAll((Collection<? extends Assertion>)newValue); | ||
322 | return; | ||
323 | case LogicproblemPackage.LOGIC_PROBLEM__RELATIONS: | ||
324 | getRelations().clear(); | ||
325 | getRelations().addAll((Collection<? extends Relation>)newValue); | ||
326 | return; | ||
327 | case LogicproblemPackage.LOGIC_PROBLEM__CONSTANTS: | ||
328 | getConstants().clear(); | ||
329 | getConstants().addAll((Collection<? extends Constant>)newValue); | ||
330 | return; | ||
331 | case LogicproblemPackage.LOGIC_PROBLEM__ELEMENTS: | ||
332 | getElements().clear(); | ||
333 | getElements().addAll((Collection<? extends DefinedElement>)newValue); | ||
334 | return; | ||
335 | case LogicproblemPackage.LOGIC_PROBLEM__CONTAINMENT_HIERARCHIES: | ||
336 | getContainmentHierarchies().clear(); | ||
337 | getContainmentHierarchies().addAll((Collection<? extends ContainmentHierarchy>)newValue); | ||
338 | return; | ||
339 | case LogicproblemPackage.LOGIC_PROBLEM__ANNOTATIONS: | ||
340 | getAnnotations().clear(); | ||
341 | getAnnotations().addAll((Collection<? extends Annotation>)newValue); | ||
342 | return; | ||
343 | } | ||
344 | super.eSet(featureID, newValue); | ||
345 | } | ||
346 | |||
347 | /** | ||
348 | * <!-- begin-user-doc --> | ||
349 | * <!-- end-user-doc --> | ||
350 | * @generated | ||
351 | */ | ||
352 | @Override | ||
353 | public void eUnset(int featureID) { | ||
354 | switch (featureID) { | ||
355 | case LogicproblemPackage.LOGIC_PROBLEM__TYPES: | ||
356 | getTypes().clear(); | ||
357 | return; | ||
358 | case LogicproblemPackage.LOGIC_PROBLEM__FUNCTIONS: | ||
359 | getFunctions().clear(); | ||
360 | return; | ||
361 | case LogicproblemPackage.LOGIC_PROBLEM__ASSERTIONS: | ||
362 | getAssertions().clear(); | ||
363 | return; | ||
364 | case LogicproblemPackage.LOGIC_PROBLEM__RELATIONS: | ||
365 | getRelations().clear(); | ||
366 | return; | ||
367 | case LogicproblemPackage.LOGIC_PROBLEM__CONSTANTS: | ||
368 | getConstants().clear(); | ||
369 | return; | ||
370 | case LogicproblemPackage.LOGIC_PROBLEM__ELEMENTS: | ||
371 | getElements().clear(); | ||
372 | return; | ||
373 | case LogicproblemPackage.LOGIC_PROBLEM__CONTAINMENT_HIERARCHIES: | ||
374 | getContainmentHierarchies().clear(); | ||
375 | return; | ||
376 | case LogicproblemPackage.LOGIC_PROBLEM__ANNOTATIONS: | ||
377 | getAnnotations().clear(); | ||
378 | return; | ||
379 | } | ||
380 | super.eUnset(featureID); | ||
381 | } | ||
382 | |||
383 | /** | ||
384 | * <!-- begin-user-doc --> | ||
385 | * <!-- end-user-doc --> | ||
386 | * @generated | ||
387 | */ | ||
388 | @Override | ||
389 | public boolean eIsSet(int featureID) { | ||
390 | switch (featureID) { | ||
391 | case LogicproblemPackage.LOGIC_PROBLEM__TYPES: | ||
392 | return types != null && !types.isEmpty(); | ||
393 | case LogicproblemPackage.LOGIC_PROBLEM__FUNCTIONS: | ||
394 | return functions != null && !functions.isEmpty(); | ||
395 | case LogicproblemPackage.LOGIC_PROBLEM__ASSERTIONS: | ||
396 | return assertions != null && !assertions.isEmpty(); | ||
397 | case LogicproblemPackage.LOGIC_PROBLEM__RELATIONS: | ||
398 | return relations != null && !relations.isEmpty(); | ||
399 | case LogicproblemPackage.LOGIC_PROBLEM__CONSTANTS: | ||
400 | return constants != null && !constants.isEmpty(); | ||
401 | case LogicproblemPackage.LOGIC_PROBLEM__ELEMENTS: | ||
402 | return elements != null && !elements.isEmpty(); | ||
403 | case LogicproblemPackage.LOGIC_PROBLEM__CONTAINMENT_HIERARCHIES: | ||
404 | return containmentHierarchies != null && !containmentHierarchies.isEmpty(); | ||
405 | case LogicproblemPackage.LOGIC_PROBLEM__ANNOTATIONS: | ||
406 | return annotations != null && !annotations.isEmpty(); | ||
407 | } | ||
408 | return super.eIsSet(featureID); | ||
409 | } | ||
410 | |||
411 | } //LogicProblemImpl | ||