From dbbf707d78c76f4bc001d7df2418bd6ceab12db3 Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Sat, 24 Mar 2018 22:08:23 -0400 Subject: example projects added --- .../impl/FAMTerminatorImpl.java | 196 +++++++ .../functionalarchitecture/impl/FunctionImpl.java | 191 +++++++ .../impl/FunctionalArchitectureModelImpl.java | 152 ++++++ .../impl/FunctionalDataImpl.java | 267 ++++++++++ .../impl/FunctionalElementImpl.java | 318 ++++++++++++ .../impl/FunctionalInputImpl.java | 165 ++++++ .../impl/FunctionalInterfaceImpl.java | 243 +++++++++ .../impl/FunctionalOutputImpl.java | 165 ++++++ .../impl/FunctionalarchitectureFactoryImpl.java | 213 ++++++++ .../impl/FunctionalarchitecturePackageImpl.java | 574 +++++++++++++++++++++ .../impl/InformationLinkImpl.java | 285 ++++++++++ 11 files changed, 2769 insertions(+) create mode 100644 Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FAMTerminatorImpl.java create mode 100644 Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionImpl.java create mode 100644 Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalArchitectureModelImpl.java create mode 100644 Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalDataImpl.java create mode 100644 Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalElementImpl.java create mode 100644 Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalInputImpl.java create mode 100644 Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalInterfaceImpl.java create mode 100644 Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalOutputImpl.java create mode 100644 Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalarchitectureFactoryImpl.java create mode 100644 Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalarchitecturePackageImpl.java create mode 100644 Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/InformationLinkImpl.java (limited to 'Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl') diff --git a/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FAMTerminatorImpl.java b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FAMTerminatorImpl.java new file mode 100644 index 00000000..382e0170 --- /dev/null +++ b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FAMTerminatorImpl.java @@ -0,0 +1,196 @@ +/** + */ +package functionalarchitecture.impl; + +import functionalarchitecture.FAMTerminator; +import functionalarchitecture.FunctionalData; +import functionalarchitecture.FunctionalarchitecturePackage; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.emf.ecore.util.EcoreUtil; + +/** + * + * An implementation of the model object 'FAM Terminator'. + * + *

+ * The following features are implemented: + *

+ * + * + * @generated + */ +public class FAMTerminatorImpl extends MinimalEObjectImpl.Container implements FAMTerminator { + /** + * + * + * @generated + */ + protected FAMTerminatorImpl() { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() { + return FunctionalarchitecturePackage.Literals.FAM_TERMINATOR; + } + + /** + * + * + * @generated + */ + public FunctionalData getData() { + if (eContainerFeatureID() != FunctionalarchitecturePackage.FAM_TERMINATOR__DATA) return null; + return (FunctionalData)eInternalContainer(); + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetData(FunctionalData newData, NotificationChain msgs) { + msgs = eBasicSetContainer((InternalEObject)newData, FunctionalarchitecturePackage.FAM_TERMINATOR__DATA, msgs); + return msgs; + } + + /** + * + * + * @generated + */ + public void setData(FunctionalData newData) { + if (newData != eInternalContainer() || (eContainerFeatureID() != FunctionalarchitecturePackage.FAM_TERMINATOR__DATA && newData != null)) { + if (EcoreUtil.isAncestor(this, newData)) + throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); + NotificationChain msgs = null; + if (eInternalContainer() != null) + msgs = eBasicRemoveFromContainer(msgs); + if (newData != null) + msgs = ((InternalEObject)newData).eInverseAdd(this, FunctionalarchitecturePackage.FUNCTIONAL_DATA__TERMINATOR, FunctionalData.class, msgs); + msgs = basicSetData(newData, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FunctionalarchitecturePackage.FAM_TERMINATOR__DATA, newData, newData)); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.FAM_TERMINATOR__DATA: + if (eInternalContainer() != null) + msgs = eBasicRemoveFromContainer(msgs); + return basicSetData((FunctionalData)otherEnd, msgs); + } + return super.eInverseAdd(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.FAM_TERMINATOR__DATA: + return basicSetData(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) { + switch (eContainerFeatureID()) { + case FunctionalarchitecturePackage.FAM_TERMINATOR__DATA: + return eInternalContainer().eInverseRemove(this, FunctionalarchitecturePackage.FUNCTIONAL_DATA__TERMINATOR, FunctionalData.class, msgs); + } + return super.eBasicRemoveFromContainerFeature(msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) { + switch (featureID) { + case FunctionalarchitecturePackage.FAM_TERMINATOR__DATA: + return getData(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) { + switch (featureID) { + case FunctionalarchitecturePackage.FAM_TERMINATOR__DATA: + setData((FunctionalData)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FAM_TERMINATOR__DATA: + setData((FunctionalData)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FAM_TERMINATOR__DATA: + return getData() != null; + } + return super.eIsSet(featureID); + } + +} //FAMTerminatorImpl diff --git a/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionImpl.java b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionImpl.java new file mode 100644 index 00000000..46736c8c --- /dev/null +++ b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionImpl.java @@ -0,0 +1,191 @@ +/** + */ +package functionalarchitecture.impl; + +import functionalarchitecture.Function; +import functionalarchitecture.FunctionType; +import functionalarchitecture.FunctionalElement; +import functionalarchitecture.FunctionalarchitecturePackage; + +import java.util.Collection; + +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EStructuralFeature; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList; +import org.eclipse.emf.ecore.util.InternalEList; + +/** + * + * An implementation of the model object 'Function'. + * + *

+ * The following features are implemented: + *

+ * + * + * @generated + */ +public class FunctionImpl extends FunctionalElementImpl implements Function { + /** + * The cached value of the '{@link #getSubElements() Sub Elements}' containment reference list. + * + * + * @see #getSubElements() + * @generated + * @ordered + */ + protected EList subElements; + + /** + * The cached setting delegate for the '{@link #getType() Type}' attribute. + * + * + * @see #getType() + * @generated + * @ordered + */ + protected EStructuralFeature.Internal.SettingDelegate TYPE__ESETTING_DELEGATE = ((EStructuralFeature.Internal)FunctionalarchitecturePackage.Literals.FUNCTION__TYPE).getSettingDelegate(); + + /** + * + * + * @generated + */ + protected FunctionImpl() { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() { + return FunctionalarchitecturePackage.Literals.FUNCTION; + } + + /** + * + * + * @generated + */ + public EList getSubElements() { + if (subElements == null) { + subElements = new EObjectContainmentWithInverseEList(FunctionalElement.class, this, FunctionalarchitecturePackage.FUNCTION__SUB_ELEMENTS, FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__PARENT); + } + return subElements; + } + + /** + * + * + * @generated + */ + public FunctionType getType() { + return (FunctionType)TYPE__ESETTING_DELEGATE.dynamicGet(this, null, 0, true, false); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTION__SUB_ELEMENTS: + return ((InternalEList)(InternalEList)getSubElements()).basicAdd(otherEnd, msgs); + } + return super.eInverseAdd(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTION__SUB_ELEMENTS: + return ((InternalEList)getSubElements()).basicRemove(otherEnd, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTION__SUB_ELEMENTS: + return getSubElements(); + case FunctionalarchitecturePackage.FUNCTION__TYPE: + return getType(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public void eSet(int featureID, Object newValue) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTION__SUB_ELEMENTS: + getSubElements().clear(); + getSubElements().addAll((Collection)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTION__SUB_ELEMENTS: + getSubElements().clear(); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTION__SUB_ELEMENTS: + return subElements != null && !subElements.isEmpty(); + case FunctionalarchitecturePackage.FUNCTION__TYPE: + return TYPE__ESETTING_DELEGATE.dynamicIsSet(this, null, 0); + } + return super.eIsSet(featureID); + } + +} //FunctionImpl diff --git a/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalArchitectureModelImpl.java b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalArchitectureModelImpl.java new file mode 100644 index 00000000..78f6d6f2 --- /dev/null +++ b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalArchitectureModelImpl.java @@ -0,0 +1,152 @@ +/** + */ +package functionalarchitecture.impl; + +import functionalarchitecture.FunctionalArchitectureModel; +import functionalarchitecture.FunctionalElement; +import functionalarchitecture.FunctionalarchitecturePackage; + +import java.util.Collection; + +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.emf.ecore.util.EObjectContainmentEList; +import org.eclipse.emf.ecore.util.InternalEList; + +/** + * + * An implementation of the model object 'Functional Architecture Model'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link functionalarchitecture.impl.FunctionalArchitectureModelImpl#getRootElements Root Elements}
    • + *
+ * + * @generated + */ +public class FunctionalArchitectureModelImpl extends MinimalEObjectImpl.Container implements FunctionalArchitectureModel { + /** + * The cached value of the '{@link #getRootElements() Root Elements}' containment reference list. + * + * + * @see #getRootElements() + * @generated + * @ordered + */ + protected EList rootElements; + + /** + * + * + * @generated + */ + protected FunctionalArchitectureModelImpl() { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() { + return FunctionalarchitecturePackage.Literals.FUNCTIONAL_ARCHITECTURE_MODEL; + } + + /** + * + * + * @generated + */ + public EList getRootElements() { + if (rootElements == null) { + rootElements = new EObjectContainmentEList(FunctionalElement.class, this, FunctionalarchitecturePackage.FUNCTIONAL_ARCHITECTURE_MODEL__ROOT_ELEMENTS); + } + return rootElements; + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_ARCHITECTURE_MODEL__ROOT_ELEMENTS: + return ((InternalEList)getRootElements()).basicRemove(otherEnd, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_ARCHITECTURE_MODEL__ROOT_ELEMENTS: + return getRootElements(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public void eSet(int featureID, Object newValue) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_ARCHITECTURE_MODEL__ROOT_ELEMENTS: + getRootElements().clear(); + getRootElements().addAll((Collection)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_ARCHITECTURE_MODEL__ROOT_ELEMENTS: + getRootElements().clear(); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_ARCHITECTURE_MODEL__ROOT_ELEMENTS: + return rootElements != null && !rootElements.isEmpty(); + } + return super.eIsSet(featureID); + } + +} //FunctionalArchitectureModelImpl diff --git a/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalDataImpl.java b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalDataImpl.java new file mode 100644 index 00000000..10937e8d --- /dev/null +++ b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalDataImpl.java @@ -0,0 +1,267 @@ +/** + */ +package functionalarchitecture.impl; + +import functionalarchitecture.FAMTerminator; +import functionalarchitecture.FunctionalData; +import functionalarchitecture.FunctionalInterface; +import functionalarchitecture.FunctionalarchitecturePackage; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.emf.ecore.util.EcoreUtil; + +/** + * + * An implementation of the model object 'Functional Data'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link functionalarchitecture.impl.FunctionalDataImpl#getTerminator Terminator}
    • + *
  • {@link functionalarchitecture.impl.FunctionalDataImpl#getInterface Interface}
    • + *
+ * + * @generated + */ +public abstract class FunctionalDataImpl extends MinimalEObjectImpl.Container implements FunctionalData { + /** + * The cached value of the '{@link #getTerminator() Terminator}' containment reference. + * + * + * @see #getTerminator() + * @generated + * @ordered + */ + protected FAMTerminator terminator; + + /** + * + * + * @generated + */ + protected FunctionalDataImpl() { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() { + return FunctionalarchitecturePackage.Literals.FUNCTIONAL_DATA; + } + + /** + * + * + * @generated + */ + public FAMTerminator getTerminator() { + return terminator; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetTerminator(FAMTerminator newTerminator, NotificationChain msgs) { + FAMTerminator oldTerminator = terminator; + terminator = newTerminator; + if (eNotificationRequired()) { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FunctionalarchitecturePackage.FUNCTIONAL_DATA__TERMINATOR, oldTerminator, newTerminator); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + public void setTerminator(FAMTerminator newTerminator) { + if (newTerminator != terminator) { + NotificationChain msgs = null; + if (terminator != null) + msgs = ((InternalEObject)terminator).eInverseRemove(this, FunctionalarchitecturePackage.FAM_TERMINATOR__DATA, FAMTerminator.class, msgs); + if (newTerminator != null) + msgs = ((InternalEObject)newTerminator).eInverseAdd(this, FunctionalarchitecturePackage.FAM_TERMINATOR__DATA, FAMTerminator.class, msgs); + msgs = basicSetTerminator(newTerminator, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FunctionalarchitecturePackage.FUNCTIONAL_DATA__TERMINATOR, newTerminator, newTerminator)); + } + + /** + * + * + * @generated + */ + public FunctionalInterface getInterface() { + if (eContainerFeatureID() != FunctionalarchitecturePackage.FUNCTIONAL_DATA__INTERFACE) return null; + return (FunctionalInterface)eInternalContainer(); + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetInterface(FunctionalInterface newInterface, NotificationChain msgs) { + msgs = eBasicSetContainer((InternalEObject)newInterface, FunctionalarchitecturePackage.FUNCTIONAL_DATA__INTERFACE, msgs); + return msgs; + } + + /** + * + * + * @generated + */ + public void setInterface(FunctionalInterface newInterface) { + if (newInterface != eInternalContainer() || (eContainerFeatureID() != FunctionalarchitecturePackage.FUNCTIONAL_DATA__INTERFACE && newInterface != null)) { + if (EcoreUtil.isAncestor(this, newInterface)) + throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); + NotificationChain msgs = null; + if (eInternalContainer() != null) + msgs = eBasicRemoveFromContainer(msgs); + if (newInterface != null) + msgs = ((InternalEObject)newInterface).eInverseAdd(this, FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__DATA, FunctionalInterface.class, msgs); + msgs = basicSetInterface(newInterface, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FunctionalarchitecturePackage.FUNCTIONAL_DATA__INTERFACE, newInterface, newInterface)); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_DATA__TERMINATOR: + if (terminator != null) + msgs = ((InternalEObject)terminator).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FunctionalarchitecturePackage.FUNCTIONAL_DATA__TERMINATOR, null, msgs); + return basicSetTerminator((FAMTerminator)otherEnd, msgs); + case FunctionalarchitecturePackage.FUNCTIONAL_DATA__INTERFACE: + if (eInternalContainer() != null) + msgs = eBasicRemoveFromContainer(msgs); + return basicSetInterface((FunctionalInterface)otherEnd, msgs); + } + return super.eInverseAdd(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_DATA__TERMINATOR: + return basicSetTerminator(null, msgs); + case FunctionalarchitecturePackage.FUNCTIONAL_DATA__INTERFACE: + return basicSetInterface(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) { + switch (eContainerFeatureID()) { + case FunctionalarchitecturePackage.FUNCTIONAL_DATA__INTERFACE: + return eInternalContainer().eInverseRemove(this, FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__DATA, FunctionalInterface.class, msgs); + } + return super.eBasicRemoveFromContainerFeature(msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_DATA__TERMINATOR: + return getTerminator(); + case FunctionalarchitecturePackage.FUNCTIONAL_DATA__INTERFACE: + return getInterface(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_DATA__TERMINATOR: + setTerminator((FAMTerminator)newValue); + return; + case FunctionalarchitecturePackage.FUNCTIONAL_DATA__INTERFACE: + setInterface((FunctionalInterface)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_DATA__TERMINATOR: + setTerminator((FAMTerminator)null); + return; + case FunctionalarchitecturePackage.FUNCTIONAL_DATA__INTERFACE: + setInterface((FunctionalInterface)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_DATA__TERMINATOR: + return terminator != null; + case FunctionalarchitecturePackage.FUNCTIONAL_DATA__INTERFACE: + return getInterface() != null; + } + return super.eIsSet(featureID); + } + +} //FunctionalDataImpl diff --git a/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalElementImpl.java b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalElementImpl.java new file mode 100644 index 00000000..809e9ed5 --- /dev/null +++ b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalElementImpl.java @@ -0,0 +1,318 @@ +/** + */ +package functionalarchitecture.impl; + +import functionalarchitecture.Function; +import functionalarchitecture.FunctionalArchitectureModel; +import functionalarchitecture.FunctionalElement; +import functionalarchitecture.FunctionalInterface; +import functionalarchitecture.FunctionalarchitecturePackage; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EStructuralFeature; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.emf.ecore.util.EcoreUtil; + +/** + * + * An implementation of the model object 'Functional Element'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link functionalarchitecture.impl.FunctionalElementImpl#getInterface Interface}
    • + *
  • {@link functionalarchitecture.impl.FunctionalElementImpl#getModel Model}
    • + *
  • {@link functionalarchitecture.impl.FunctionalElementImpl#getParent Parent}
    • + *
+ * + * @generated + */ +public abstract class FunctionalElementImpl extends MinimalEObjectImpl.Container implements FunctionalElement { + /** + * The cached value of the '{@link #getInterface() Interface}' containment reference. + * + * + * @see #getInterface() + * @generated + * @ordered + */ + protected FunctionalInterface interface_; + + /** + * The cached setting delegate for the '{@link #getModel() Model}' reference. + * + * + * @see #getModel() + * @generated + * @ordered + */ + protected EStructuralFeature.Internal.SettingDelegate MODEL__ESETTING_DELEGATE = ((EStructuralFeature.Internal)FunctionalarchitecturePackage.Literals.FUNCTIONAL_ELEMENT__MODEL).getSettingDelegate(); + + /** + * + * + * @generated + */ + protected FunctionalElementImpl() { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() { + return FunctionalarchitecturePackage.Literals.FUNCTIONAL_ELEMENT; + } + + /** + * + * + * @generated + */ + public FunctionalInterface getInterface() { + return interface_; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetInterface(FunctionalInterface newInterface, NotificationChain msgs) { + FunctionalInterface oldInterface = interface_; + interface_ = newInterface; + if (eNotificationRequired()) { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__INTERFACE, oldInterface, newInterface); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + public void setInterface(FunctionalInterface newInterface) { + if (newInterface != interface_) { + NotificationChain msgs = null; + if (interface_ != null) + msgs = ((InternalEObject)interface_).eInverseRemove(this, FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__ELEMENT, FunctionalInterface.class, msgs); + if (newInterface != null) + msgs = ((InternalEObject)newInterface).eInverseAdd(this, FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__ELEMENT, FunctionalInterface.class, msgs); + msgs = basicSetInterface(newInterface, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__INTERFACE, newInterface, newInterface)); + } + + /** + * + * + * @generated + */ + public FunctionalArchitectureModel getModel() { + return (FunctionalArchitectureModel)MODEL__ESETTING_DELEGATE.dynamicGet(this, null, 0, true, false); + } + + /** + * + * + * @generated + */ + public FunctionalArchitectureModel basicGetModel() { + return (FunctionalArchitectureModel)MODEL__ESETTING_DELEGATE.dynamicGet(this, null, 0, false, false); + } + + /** + * + * + * @generated + */ + public void setModel(FunctionalArchitectureModel newModel) { + MODEL__ESETTING_DELEGATE.dynamicSet(this, null, 0, newModel); + } + + /** + * + * + * @generated + */ + public Function getParent() { + if (eContainerFeatureID() != FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__PARENT) return null; + return (Function)eInternalContainer(); + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetParent(Function newParent, NotificationChain msgs) { + msgs = eBasicSetContainer((InternalEObject)newParent, FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__PARENT, msgs); + return msgs; + } + + /** + * + * + * @generated + */ + public void setParent(Function newParent) { + if (newParent != eInternalContainer() || (eContainerFeatureID() != FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__PARENT && newParent != null)) { + if (EcoreUtil.isAncestor(this, newParent)) + throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); + NotificationChain msgs = null; + if (eInternalContainer() != null) + msgs = eBasicRemoveFromContainer(msgs); + if (newParent != null) + msgs = ((InternalEObject)newParent).eInverseAdd(this, FunctionalarchitecturePackage.FUNCTION__SUB_ELEMENTS, Function.class, msgs); + msgs = basicSetParent(newParent, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__PARENT, newParent, newParent)); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__INTERFACE: + if (interface_ != null) + msgs = ((InternalEObject)interface_).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__INTERFACE, null, msgs); + return basicSetInterface((FunctionalInterface)otherEnd, msgs); + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__PARENT: + if (eInternalContainer() != null) + msgs = eBasicRemoveFromContainer(msgs); + return basicSetParent((Function)otherEnd, msgs); + } + return super.eInverseAdd(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__INTERFACE: + return basicSetInterface(null, msgs); + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__PARENT: + return basicSetParent(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) { + switch (eContainerFeatureID()) { + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__PARENT: + return eInternalContainer().eInverseRemove(this, FunctionalarchitecturePackage.FUNCTION__SUB_ELEMENTS, Function.class, msgs); + } + return super.eBasicRemoveFromContainerFeature(msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__INTERFACE: + return getInterface(); + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__MODEL: + if (resolve) return getModel(); + return basicGetModel(); + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__PARENT: + return getParent(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__INTERFACE: + setInterface((FunctionalInterface)newValue); + return; + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__MODEL: + setModel((FunctionalArchitectureModel)newValue); + return; + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__PARENT: + setParent((Function)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__INTERFACE: + setInterface((FunctionalInterface)null); + return; + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__MODEL: + setModel((FunctionalArchitectureModel)null); + return; + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__PARENT: + setParent((Function)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__INTERFACE: + return interface_ != null; + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__MODEL: + return MODEL__ESETTING_DELEGATE.dynamicIsSet(this, null, 0); + case FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__PARENT: + return getParent() != null; + } + return super.eIsSet(featureID); + } + +} //FunctionalElementImpl diff --git a/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalInputImpl.java b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalInputImpl.java new file mode 100644 index 00000000..9df1ec0c --- /dev/null +++ b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalInputImpl.java @@ -0,0 +1,165 @@ +/** + */ +package functionalarchitecture.impl; + +import functionalarchitecture.FunctionalInput; +import functionalarchitecture.FunctionalarchitecturePackage; +import functionalarchitecture.InformationLink; + +import java.util.Collection; + +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.util.EObjectWithInverseResolvingEList; +import org.eclipse.emf.ecore.util.InternalEList; + +/** + * + * An implementation of the model object 'Functional Input'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link functionalarchitecture.impl.FunctionalInputImpl#getIncomingLinks Incoming Links}
    • + *
+ * + * @generated + */ +public class FunctionalInputImpl extends FunctionalDataImpl implements FunctionalInput { + /** + * The cached value of the '{@link #getIncomingLinks() Incoming Links}' reference list. + * + * + * @see #getIncomingLinks() + * @generated + * @ordered + */ + protected EList incomingLinks; + + /** + * + * + * @generated + */ + protected FunctionalInputImpl() { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() { + return FunctionalarchitecturePackage.Literals.FUNCTIONAL_INPUT; + } + + /** + * + * + * @generated + */ + public EList getIncomingLinks() { + if (incomingLinks == null) { + incomingLinks = new EObjectWithInverseResolvingEList(InformationLink.class, this, FunctionalarchitecturePackage.FUNCTIONAL_INPUT__INCOMING_LINKS, FunctionalarchitecturePackage.INFORMATION_LINK__TO); + } + return incomingLinks; + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_INPUT__INCOMING_LINKS: + return ((InternalEList)(InternalEList)getIncomingLinks()).basicAdd(otherEnd, msgs); + } + return super.eInverseAdd(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_INPUT__INCOMING_LINKS: + return ((InternalEList)getIncomingLinks()).basicRemove(otherEnd, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_INPUT__INCOMING_LINKS: + return getIncomingLinks(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public void eSet(int featureID, Object newValue) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_INPUT__INCOMING_LINKS: + getIncomingLinks().clear(); + getIncomingLinks().addAll((Collection)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_INPUT__INCOMING_LINKS: + getIncomingLinks().clear(); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_INPUT__INCOMING_LINKS: + return incomingLinks != null && !incomingLinks.isEmpty(); + } + return super.eIsSet(featureID); + } + +} //FunctionalInputImpl diff --git a/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalInterfaceImpl.java b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalInterfaceImpl.java new file mode 100644 index 00000000..20151886 --- /dev/null +++ b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalInterfaceImpl.java @@ -0,0 +1,243 @@ +/** + */ +package functionalarchitecture.impl; + +import functionalarchitecture.FunctionalData; +import functionalarchitecture.FunctionalElement; +import functionalarchitecture.FunctionalInterface; +import functionalarchitecture.FunctionalarchitecturePackage; + +import java.util.Collection; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.ecore.util.InternalEList; + +/** + * + * An implementation of the model object 'Functional Interface'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link functionalarchitecture.impl.FunctionalInterfaceImpl#getData Data}
    • + *
  • {@link functionalarchitecture.impl.FunctionalInterfaceImpl#getElement Element}
    • + *
+ * + * @generated + */ +public class FunctionalInterfaceImpl extends MinimalEObjectImpl.Container implements FunctionalInterface { + /** + * The cached value of the '{@link #getData() Data}' containment reference list. + * + * + * @see #getData() + * @generated + * @ordered + */ + protected EList data; + + /** + * + * + * @generated + */ + protected FunctionalInterfaceImpl() { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() { + return FunctionalarchitecturePackage.Literals.FUNCTIONAL_INTERFACE; + } + + /** + * + * + * @generated + */ + public EList getData() { + if (data == null) { + data = new EObjectContainmentWithInverseEList(FunctionalData.class, this, FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__DATA, FunctionalarchitecturePackage.FUNCTIONAL_DATA__INTERFACE); + } + return data; + } + + /** + * + * + * @generated + */ + public FunctionalElement getElement() { + if (eContainerFeatureID() != FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__ELEMENT) return null; + return (FunctionalElement)eInternalContainer(); + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetElement(FunctionalElement newElement, NotificationChain msgs) { + msgs = eBasicSetContainer((InternalEObject)newElement, FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__ELEMENT, msgs); + return msgs; + } + + /** + * + * + * @generated + */ + public void setElement(FunctionalElement newElement) { + if (newElement != eInternalContainer() || (eContainerFeatureID() != FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__ELEMENT && newElement != null)) { + if (EcoreUtil.isAncestor(this, newElement)) + throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); + NotificationChain msgs = null; + if (eInternalContainer() != null) + msgs = eBasicRemoveFromContainer(msgs); + if (newElement != null) + msgs = ((InternalEObject)newElement).eInverseAdd(this, FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__INTERFACE, FunctionalElement.class, msgs); + msgs = basicSetElement(newElement, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__ELEMENT, newElement, newElement)); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__DATA: + return ((InternalEList)(InternalEList)getData()).basicAdd(otherEnd, msgs); + case FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__ELEMENT: + if (eInternalContainer() != null) + msgs = eBasicRemoveFromContainer(msgs); + return basicSetElement((FunctionalElement)otherEnd, msgs); + } + return super.eInverseAdd(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__DATA: + return ((InternalEList)getData()).basicRemove(otherEnd, msgs); + case FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__ELEMENT: + return basicSetElement(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) { + switch (eContainerFeatureID()) { + case FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__ELEMENT: + return eInternalContainer().eInverseRemove(this, FunctionalarchitecturePackage.FUNCTIONAL_ELEMENT__INTERFACE, FunctionalElement.class, msgs); + } + return super.eBasicRemoveFromContainerFeature(msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__DATA: + return getData(); + case FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__ELEMENT: + return getElement(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public void eSet(int featureID, Object newValue) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__DATA: + getData().clear(); + getData().addAll((Collection)newValue); + return; + case FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__ELEMENT: + setElement((FunctionalElement)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__DATA: + getData().clear(); + return; + case FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__ELEMENT: + setElement((FunctionalElement)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__DATA: + return data != null && !data.isEmpty(); + case FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE__ELEMENT: + return getElement() != null; + } + return super.eIsSet(featureID); + } + +} //FunctionalInterfaceImpl diff --git a/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalOutputImpl.java b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalOutputImpl.java new file mode 100644 index 00000000..1ae2a964 --- /dev/null +++ b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalOutputImpl.java @@ -0,0 +1,165 @@ +/** + */ +package functionalarchitecture.impl; + +import functionalarchitecture.FunctionalOutput; +import functionalarchitecture.FunctionalarchitecturePackage; +import functionalarchitecture.InformationLink; + +import java.util.Collection; + +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList; +import org.eclipse.emf.ecore.util.InternalEList; + +/** + * + * An implementation of the model object 'Functional Output'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link functionalarchitecture.impl.FunctionalOutputImpl#getOutgoingLinks Outgoing Links}
    • + *
+ * + * @generated + */ +public class FunctionalOutputImpl extends FunctionalDataImpl implements FunctionalOutput { + /** + * The cached value of the '{@link #getOutgoingLinks() Outgoing Links}' containment reference list. + * + * + * @see #getOutgoingLinks() + * @generated + * @ordered + */ + protected EList outgoingLinks; + + /** + * + * + * @generated + */ + protected FunctionalOutputImpl() { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() { + return FunctionalarchitecturePackage.Literals.FUNCTIONAL_OUTPUT; + } + + /** + * + * + * @generated + */ + public EList getOutgoingLinks() { + if (outgoingLinks == null) { + outgoingLinks = new EObjectContainmentWithInverseEList(InformationLink.class, this, FunctionalarchitecturePackage.FUNCTIONAL_OUTPUT__OUTGOING_LINKS, FunctionalarchitecturePackage.INFORMATION_LINK__FROM); + } + return outgoingLinks; + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_OUTPUT__OUTGOING_LINKS: + return ((InternalEList)(InternalEList)getOutgoingLinks()).basicAdd(otherEnd, msgs); + } + return super.eInverseAdd(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_OUTPUT__OUTGOING_LINKS: + return ((InternalEList)getOutgoingLinks()).basicRemove(otherEnd, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_OUTPUT__OUTGOING_LINKS: + return getOutgoingLinks(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public void eSet(int featureID, Object newValue) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_OUTPUT__OUTGOING_LINKS: + getOutgoingLinks().clear(); + getOutgoingLinks().addAll((Collection)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_OUTPUT__OUTGOING_LINKS: + getOutgoingLinks().clear(); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.FUNCTIONAL_OUTPUT__OUTGOING_LINKS: + return outgoingLinks != null && !outgoingLinks.isEmpty(); + } + return super.eIsSet(featureID); + } + +} //FunctionalOutputImpl diff --git a/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalarchitectureFactoryImpl.java b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalarchitectureFactoryImpl.java new file mode 100644 index 00000000..56ecfa25 --- /dev/null +++ b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalarchitectureFactoryImpl.java @@ -0,0 +1,213 @@ +/** + */ +package functionalarchitecture.impl; + +import functionalarchitecture.*; +import functionalarchitecture.FunctionalInterface; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EDataType; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EPackage; + +import org.eclipse.emf.ecore.impl.EFactoryImpl; + +import org.eclipse.emf.ecore.plugin.EcorePlugin; + +/** + * + * An implementation of the model Factory. + * + * @generated + */ +public class FunctionalarchitectureFactoryImpl extends EFactoryImpl implements FunctionalarchitectureFactory { + /** + * Creates the default factory implementation. + * + * + * @generated + */ + public static FunctionalarchitectureFactory init() { + try { + FunctionalarchitectureFactory theFunctionalarchitectureFactory = (FunctionalarchitectureFactory)EPackage.Registry.INSTANCE.getEFactory(FunctionalarchitecturePackage.eNS_URI); + if (theFunctionalarchitectureFactory != null) { + return theFunctionalarchitectureFactory; + } + } + catch (Exception exception) { + EcorePlugin.INSTANCE.log(exception); + } + return new FunctionalarchitectureFactoryImpl(); + } + + /** + * Creates an instance of the factory. + * + * + * @generated + */ + public FunctionalarchitectureFactoryImpl() { + super(); + } + + /** + * + * + * @generated + */ + @Override + public EObject create(EClass eClass) { + switch (eClass.getClassifierID()) { + case FunctionalarchitecturePackage.FUNCTIONAL_ARCHITECTURE_MODEL: return createFunctionalArchitectureModel(); + case FunctionalarchitecturePackage.FUNCTION: return createFunction(); + case FunctionalarchitecturePackage.FAM_TERMINATOR: return createFAMTerminator(); + case FunctionalarchitecturePackage.INFORMATION_LINK: return createInformationLink(); + case FunctionalarchitecturePackage.FUNCTIONAL_INTERFACE: return createFunctionalInterface(); + case FunctionalarchitecturePackage.FUNCTIONAL_INPUT: return createFunctionalInput(); + case FunctionalarchitecturePackage.FUNCTIONAL_OUTPUT: return createFunctionalOutput(); + default: + throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier"); + } + } + + /** + * + * + * @generated + */ + @Override + public Object createFromString(EDataType eDataType, String initialValue) { + switch (eDataType.getClassifierID()) { + case FunctionalarchitecturePackage.FUNCTION_TYPE: + return createFunctionTypeFromString(eDataType, initialValue); + default: + throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier"); + } + } + + /** + * + * + * @generated + */ + @Override + public String convertToString(EDataType eDataType, Object instanceValue) { + switch (eDataType.getClassifierID()) { + case FunctionalarchitecturePackage.FUNCTION_TYPE: + return convertFunctionTypeToString(eDataType, instanceValue); + default: + throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier"); + } + } + + /** + * + * + * @generated + */ + public FunctionalArchitectureModel createFunctionalArchitectureModel() { + FunctionalArchitectureModelImpl functionalArchitectureModel = new FunctionalArchitectureModelImpl(); + return functionalArchitectureModel; + } + + /** + * + * + * @generated + */ + public Function createFunction() { + FunctionImpl function = new FunctionImpl(); + return function; + } + + /** + * + * + * @generated + */ + public FAMTerminator createFAMTerminator() { + FAMTerminatorImpl famTerminator = new FAMTerminatorImpl(); + return famTerminator; + } + + /** + * + * + * @generated + */ + public InformationLink createInformationLink() { + InformationLinkImpl informationLink = new InformationLinkImpl(); + return informationLink; + } + + /** + * + * + * @generated + */ + public FunctionalInterface createFunctionalInterface() { + FunctionalInterfaceImpl functionalInterface = new FunctionalInterfaceImpl(); + return functionalInterface; + } + + /** + * + * + * @generated + */ + public FunctionalInput createFunctionalInput() { + FunctionalInputImpl functionalInput = new FunctionalInputImpl(); + return functionalInput; + } + + /** + * + * + * @generated + */ + public FunctionalOutput createFunctionalOutput() { + FunctionalOutputImpl functionalOutput = new FunctionalOutputImpl(); + return functionalOutput; + } + + /** + * + * + * @generated + */ + public FunctionType createFunctionTypeFromString(EDataType eDataType, String initialValue) { + FunctionType result = FunctionType.get(initialValue); + if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); + return result; + } + + /** + * + * + * @generated + */ + public String convertFunctionTypeToString(EDataType eDataType, Object instanceValue) { + return instanceValue == null ? null : instanceValue.toString(); + } + + /** + * + * + * @generated + */ + public FunctionalarchitecturePackage getFunctionalarchitecturePackage() { + return (FunctionalarchitecturePackage)getEPackage(); + } + + /** + * + * + * @deprecated + * @generated + */ + @Deprecated + public static FunctionalarchitecturePackage getPackage() { + return FunctionalarchitecturePackage.eINSTANCE; + } + +} //FunctionalarchitectureFactoryImpl diff --git a/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalarchitecturePackageImpl.java b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalarchitecturePackageImpl.java new file mode 100644 index 00000000..22c15533 --- /dev/null +++ b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/FunctionalarchitecturePackageImpl.java @@ -0,0 +1,574 @@ +/** + */ +package functionalarchitecture.impl; + +import functionalarchitecture.FAMTerminator; +import functionalarchitecture.Function; +import functionalarchitecture.FunctionType; +import functionalarchitecture.FunctionalArchitectureModel; +import functionalarchitecture.FunctionalData; +import functionalarchitecture.FunctionalElement; +import functionalarchitecture.FunctionalInput; +import functionalarchitecture.FunctionalInterface; +import functionalarchitecture.FunctionalOutput; +import functionalarchitecture.FunctionalarchitectureFactory; +import functionalarchitecture.FunctionalarchitecturePackage; +import functionalarchitecture.InformationLink; + +import org.eclipse.emf.ecore.EAttribute; +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EEnum; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.emf.ecore.EReference; + +import org.eclipse.emf.ecore.impl.EPackageImpl; + +/** + * + * An implementation of the model Package. + * + * @generated + */ +public class FunctionalarchitecturePackageImpl extends EPackageImpl implements FunctionalarchitecturePackage { + /** + * + * + * @generated + */ + private EClass functionalElementEClass = null; + + /** + * + * + * @generated + */ + private EClass functionalArchitectureModelEClass = null; + + /** + * + * + * @generated + */ + private EClass functionEClass = null; + + /** + * + * + * @generated + */ + private EClass famTerminatorEClass = null; + + /** + * + * + * @generated + */ + private EClass informationLinkEClass = null; + + /** + * + * + * @generated + */ + private EClass functionalInterfaceEClass = null; + + /** + * + * + * @generated + */ + private EClass functionalInputEClass = null; + + /** + * + * + * @generated + */ + private EClass functionalOutputEClass = null; + + /** + * + * + * @generated + */ + private EClass functionalDataEClass = null; + + /** + * + * + * @generated + */ + private EEnum functionTypeEEnum = null; + + /** + * Creates an instance of the model Package, registered with + * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package + * package URI value. + *

Note: the correct way to create the package is via the static + * factory method {@link #init init()}, which also performs + * initialization of the package, or returns the registered package, + * if one already exists. + * + * + * @see org.eclipse.emf.ecore.EPackage.Registry + * @see functionalarchitecture.FunctionalarchitecturePackage#eNS_URI + * @see #init() + * @generated + */ + private FunctionalarchitecturePackageImpl() { + super(eNS_URI, FunctionalarchitectureFactory.eINSTANCE); + } + + /** + * + * + * @generated + */ + private static boolean isInited = false; + + /** + * Creates, registers, and initializes the Package for this model, and for any others upon which it depends. + * + *

This method is used to initialize {@link FunctionalarchitecturePackage#eINSTANCE} when that field is accessed. + * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package. + * + * + * @see #eNS_URI + * @see #createPackageContents() + * @see #initializePackageContents() + * @generated + */ + public static FunctionalarchitecturePackage init() { + if (isInited) return (FunctionalarchitecturePackage)EPackage.Registry.INSTANCE.getEPackage(FunctionalarchitecturePackage.eNS_URI); + + // Obtain or create and register package + FunctionalarchitecturePackageImpl theFunctionalarchitecturePackage = (FunctionalarchitecturePackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof FunctionalarchitecturePackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new FunctionalarchitecturePackageImpl()); + + isInited = true; + + // Create package meta-data objects + theFunctionalarchitecturePackage.createPackageContents(); + + // Initialize created meta-data + theFunctionalarchitecturePackage.initializePackageContents(); + + // Mark meta-data to indicate it can't be changed + theFunctionalarchitecturePackage.freeze(); + + + // Update the registry and return the package + EPackage.Registry.INSTANCE.put(FunctionalarchitecturePackage.eNS_URI, theFunctionalarchitecturePackage); + return theFunctionalarchitecturePackage; + } + + /** + * + * + * @generated + */ + public EClass getFunctionalElement() { + return functionalElementEClass; + } + + /** + * + * + * @generated + */ + public EReference getFunctionalElement_Interface() { + return (EReference)functionalElementEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getFunctionalElement_Model() { + return (EReference)functionalElementEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EReference getFunctionalElement_Parent() { + return (EReference)functionalElementEClass.getEStructuralFeatures().get(2); + } + + /** + * + * + * @generated + */ + public EClass getFunctionalArchitectureModel() { + return functionalArchitectureModelEClass; + } + + /** + * + * + * @generated + */ + public EReference getFunctionalArchitectureModel_RootElements() { + return (EReference)functionalArchitectureModelEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getFunction() { + return functionEClass; + } + + /** + * + * + * @generated + */ + public EReference getFunction_SubElements() { + return (EReference)functionEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EAttribute getFunction_Type() { + return (EAttribute)functionEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getFAMTerminator() { + return famTerminatorEClass; + } + + /** + * + * + * @generated + */ + public EReference getFAMTerminator_Data() { + return (EReference)famTerminatorEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getInformationLink() { + return informationLinkEClass; + } + + /** + * + * + * @generated + */ + public EReference getInformationLink_From() { + return (EReference)informationLinkEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getInformationLink_To() { + return (EReference)informationLinkEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getFunctionalInterface() { + return functionalInterfaceEClass; + } + + /** + * + * + * @generated + */ + public EReference getFunctionalInterface_Data() { + return (EReference)functionalInterfaceEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getFunctionalInterface_Element() { + return (EReference)functionalInterfaceEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getFunctionalInput() { + return functionalInputEClass; + } + + /** + * + * + * @generated + */ + public EReference getFunctionalInput_IncomingLinks() { + return (EReference)functionalInputEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getFunctionalOutput() { + return functionalOutputEClass; + } + + /** + * + * + * @generated + */ + public EReference getFunctionalOutput_OutgoingLinks() { + return (EReference)functionalOutputEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getFunctionalData() { + return functionalDataEClass; + } + + /** + * + * + * @generated + */ + public EReference getFunctionalData_Terminator() { + return (EReference)functionalDataEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getFunctionalData_Interface() { + return (EReference)functionalDataEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EEnum getFunctionType() { + return functionTypeEEnum; + } + + /** + * + * + * @generated + */ + public FunctionalarchitectureFactory getFunctionalarchitectureFactory() { + return (FunctionalarchitectureFactory)getEFactoryInstance(); + } + + /** + * + * + * @generated + */ + private boolean isCreated = false; + + /** + * Creates the meta-model objects for the package. This method is + * guarded to have no affect on any invocation but its first. + * + * + * @generated + */ + public void createPackageContents() { + if (isCreated) return; + isCreated = true; + + // Create classes and their features + functionalElementEClass = createEClass(FUNCTIONAL_ELEMENT); + createEReference(functionalElementEClass, FUNCTIONAL_ELEMENT__INTERFACE); + createEReference(functionalElementEClass, FUNCTIONAL_ELEMENT__MODEL); + createEReference(functionalElementEClass, FUNCTIONAL_ELEMENT__PARENT); + + functionalArchitectureModelEClass = createEClass(FUNCTIONAL_ARCHITECTURE_MODEL); + createEReference(functionalArchitectureModelEClass, FUNCTIONAL_ARCHITECTURE_MODEL__ROOT_ELEMENTS); + + functionEClass = createEClass(FUNCTION); + createEReference(functionEClass, FUNCTION__SUB_ELEMENTS); + createEAttribute(functionEClass, FUNCTION__TYPE); + + famTerminatorEClass = createEClass(FAM_TERMINATOR); + createEReference(famTerminatorEClass, FAM_TERMINATOR__DATA); + + informationLinkEClass = createEClass(INFORMATION_LINK); + createEReference(informationLinkEClass, INFORMATION_LINK__FROM); + createEReference(informationLinkEClass, INFORMATION_LINK__TO); + + functionalInterfaceEClass = createEClass(FUNCTIONAL_INTERFACE); + createEReference(functionalInterfaceEClass, FUNCTIONAL_INTERFACE__DATA); + createEReference(functionalInterfaceEClass, FUNCTIONAL_INTERFACE__ELEMENT); + + functionalInputEClass = createEClass(FUNCTIONAL_INPUT); + createEReference(functionalInputEClass, FUNCTIONAL_INPUT__INCOMING_LINKS); + + functionalOutputEClass = createEClass(FUNCTIONAL_OUTPUT); + createEReference(functionalOutputEClass, FUNCTIONAL_OUTPUT__OUTGOING_LINKS); + + functionalDataEClass = createEClass(FUNCTIONAL_DATA); + createEReference(functionalDataEClass, FUNCTIONAL_DATA__TERMINATOR); + createEReference(functionalDataEClass, FUNCTIONAL_DATA__INTERFACE); + + // Create enums + functionTypeEEnum = createEEnum(FUNCTION_TYPE); + } + + /** + * + * + * @generated + */ + private boolean isInitialized = false; + + /** + * Complete the initialization of the package and its meta-model. This + * method is guarded to have no affect on any invocation but its first. + * + * + * @generated + */ + public void initializePackageContents() { + if (isInitialized) return; + isInitialized = true; + + // Initialize package + setName(eNAME); + setNsPrefix(eNS_PREFIX); + setNsURI(eNS_URI); + + // Create type parameters + + // Set bounds for type parameters + + // Add supertypes to classes + functionEClass.getESuperTypes().add(this.getFunctionalElement()); + functionalInputEClass.getESuperTypes().add(this.getFunctionalData()); + functionalOutputEClass.getESuperTypes().add(this.getFunctionalData()); + + // Initialize classes, features, and operations; add parameters + initEClass(functionalElementEClass, FunctionalElement.class, "FunctionalElement", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getFunctionalElement_Interface(), this.getFunctionalInterface(), this.getFunctionalInterface_Element(), "interface", null, 0, 1, FunctionalElement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getFunctionalElement_Model(), this.getFunctionalArchitectureModel(), null, "model", null, 1, 1, FunctionalElement.class, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED); + initEReference(getFunctionalElement_Parent(), this.getFunction(), this.getFunction_SubElements(), "parent", null, 0, 1, FunctionalElement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(functionalArchitectureModelEClass, FunctionalArchitectureModel.class, "FunctionalArchitectureModel", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getFunctionalArchitectureModel_RootElements(), this.getFunctionalElement(), null, "rootElements", null, 0, -1, FunctionalArchitectureModel.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(functionEClass, Function.class, "Function", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getFunction_SubElements(), this.getFunctionalElement(), this.getFunctionalElement_Parent(), "subElements", null, 0, -1, Function.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEAttribute(getFunction_Type(), this.getFunctionType(), "type", null, 1, 1, Function.class, IS_TRANSIENT, IS_VOLATILE, !IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, IS_DERIVED, IS_ORDERED); + + initEClass(famTerminatorEClass, FAMTerminator.class, "FAMTerminator", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getFAMTerminator_Data(), this.getFunctionalData(), this.getFunctionalData_Terminator(), "data", null, 0, 1, FAMTerminator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(informationLinkEClass, InformationLink.class, "InformationLink", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getInformationLink_From(), this.getFunctionalOutput(), this.getFunctionalOutput_OutgoingLinks(), "from", null, 0, 1, InformationLink.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getInformationLink_To(), this.getFunctionalInput(), this.getFunctionalInput_IncomingLinks(), "to", null, 1, 1, InformationLink.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(functionalInterfaceEClass, FunctionalInterface.class, "FunctionalInterface", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getFunctionalInterface_Data(), this.getFunctionalData(), this.getFunctionalData_Interface(), "data", null, 0, -1, FunctionalInterface.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getFunctionalInterface_Element(), this.getFunctionalElement(), this.getFunctionalElement_Interface(), "element", null, 0, 1, FunctionalInterface.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(functionalInputEClass, FunctionalInput.class, "FunctionalInput", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getFunctionalInput_IncomingLinks(), this.getInformationLink(), this.getInformationLink_To(), "IncomingLinks", null, 0, -1, FunctionalInput.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(functionalOutputEClass, FunctionalOutput.class, "FunctionalOutput", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getFunctionalOutput_OutgoingLinks(), this.getInformationLink(), this.getInformationLink_From(), "outgoingLinks", null, 0, -1, FunctionalOutput.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(functionalDataEClass, FunctionalData.class, "FunctionalData", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getFunctionalData_Terminator(), this.getFAMTerminator(), this.getFAMTerminator_Data(), "terminator", null, 0, 1, FunctionalData.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getFunctionalData_Interface(), this.getFunctionalInterface(), this.getFunctionalInterface_Data(), "interface", null, 0, 1, FunctionalData.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + // Initialize enums and add enum literals + initEEnum(functionTypeEEnum, FunctionType.class, "FunctionType"); + addEEnumLiteral(functionTypeEEnum, FunctionType.ROOT); + addEEnumLiteral(functionTypeEEnum, FunctionType.INTERMEDIATE); + addEEnumLiteral(functionTypeEEnum, FunctionType.LEAF); + + // Create resource + createResource(eNS_URI); + + // Create annotations + // http://www.eclipse.org/emf/2002/Ecore + createEcoreAnnotations(); + // org.eclipse.viatra.query.querybasedfeature + createOrgAnnotations(); + } + + /** + * Initializes the annotations for http://www.eclipse.org/emf/2002/Ecore. + * + * + * @generated + */ + protected void createEcoreAnnotations() { + String source = "http://www.eclipse.org/emf/2002/Ecore"; + addAnnotation + (this, + source, + new String[] { + "settingDelegates", "org.eclipse.viatra.query.querybasedfeature" + }); + } + + /** + * Initializes the annotations for org.eclipse.viatra.query.querybasedfeature. + * + * + * @generated + */ + protected void createOrgAnnotations() { + String source = "org.eclipse.viatra.query.querybasedfeature"; + addAnnotation + (getFunctionalElement_Model(), + source, + new String[] { + "patternFQN", "hu.bme.mit.inf.dslreasoner.domains.transima.fam.model" + }); + addAnnotation + (getFunction_Type(), + source, + new String[] { + "patternFQN", "hu.bme.mit.inf.dslreasoner.domains.transima.fam.type" + }); + } + +} //FunctionalarchitecturePackageImpl diff --git a/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/InformationLinkImpl.java b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/InformationLinkImpl.java new file mode 100644 index 00000000..4b46fef8 --- /dev/null +++ b/Domains/Examples/ModelGenExampleFAM_plugin/ecore-gen/functionalarchitecture/impl/InformationLinkImpl.java @@ -0,0 +1,285 @@ +/** + */ +package functionalarchitecture.impl; + +import functionalarchitecture.FunctionalInput; +import functionalarchitecture.FunctionalOutput; +import functionalarchitecture.FunctionalarchitecturePackage; +import functionalarchitecture.InformationLink; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.emf.ecore.util.EcoreUtil; + +/** + * + * An implementation of the model object 'Information Link'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link functionalarchitecture.impl.InformationLinkImpl#getFrom From}
    • + *
  • {@link functionalarchitecture.impl.InformationLinkImpl#getTo To}
    • + *
+ * + * @generated + */ +public class InformationLinkImpl extends MinimalEObjectImpl.Container implements InformationLink { + /** + * The cached value of the '{@link #getTo() To}' reference. + * + * + * @see #getTo() + * @generated + * @ordered + */ + protected FunctionalInput to; + + /** + * + * + * @generated + */ + protected InformationLinkImpl() { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() { + return FunctionalarchitecturePackage.Literals.INFORMATION_LINK; + } + + /** + * + * + * @generated + */ + public FunctionalOutput getFrom() { + if (eContainerFeatureID() != FunctionalarchitecturePackage.INFORMATION_LINK__FROM) return null; + return (FunctionalOutput)eInternalContainer(); + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetFrom(FunctionalOutput newFrom, NotificationChain msgs) { + msgs = eBasicSetContainer((InternalEObject)newFrom, FunctionalarchitecturePackage.INFORMATION_LINK__FROM, msgs); + return msgs; + } + + /** + * + * + * @generated + */ + public void setFrom(FunctionalOutput newFrom) { + if (newFrom != eInternalContainer() || (eContainerFeatureID() != FunctionalarchitecturePackage.INFORMATION_LINK__FROM && newFrom != null)) { + if (EcoreUtil.isAncestor(this, newFrom)) + throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); + NotificationChain msgs = null; + if (eInternalContainer() != null) + msgs = eBasicRemoveFromContainer(msgs); + if (newFrom != null) + msgs = ((InternalEObject)newFrom).eInverseAdd(this, FunctionalarchitecturePackage.FUNCTIONAL_OUTPUT__OUTGOING_LINKS, FunctionalOutput.class, msgs); + msgs = basicSetFrom(newFrom, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FunctionalarchitecturePackage.INFORMATION_LINK__FROM, newFrom, newFrom)); + } + + /** + * + * + * @generated + */ + public FunctionalInput getTo() { + if (to != null && to.eIsProxy()) { + InternalEObject oldTo = (InternalEObject)to; + to = (FunctionalInput)eResolveProxy(oldTo); + if (to != oldTo) { + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.RESOLVE, FunctionalarchitecturePackage.INFORMATION_LINK__TO, oldTo, to)); + } + } + return to; + } + + /** + * + * + * @generated + */ + public FunctionalInput basicGetTo() { + return to; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetTo(FunctionalInput newTo, NotificationChain msgs) { + FunctionalInput oldTo = to; + to = newTo; + if (eNotificationRequired()) { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FunctionalarchitecturePackage.INFORMATION_LINK__TO, oldTo, newTo); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + public void setTo(FunctionalInput newTo) { + if (newTo != to) { + NotificationChain msgs = null; + if (to != null) + msgs = ((InternalEObject)to).eInverseRemove(this, FunctionalarchitecturePackage.FUNCTIONAL_INPUT__INCOMING_LINKS, FunctionalInput.class, msgs); + if (newTo != null) + msgs = ((InternalEObject)newTo).eInverseAdd(this, FunctionalarchitecturePackage.FUNCTIONAL_INPUT__INCOMING_LINKS, FunctionalInput.class, msgs); + msgs = basicSetTo(newTo, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FunctionalarchitecturePackage.INFORMATION_LINK__TO, newTo, newTo)); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.INFORMATION_LINK__FROM: + if (eInternalContainer() != null) + msgs = eBasicRemoveFromContainer(msgs); + return basicSetFrom((FunctionalOutput)otherEnd, msgs); + case FunctionalarchitecturePackage.INFORMATION_LINK__TO: + if (to != null) + msgs = ((InternalEObject)to).eInverseRemove(this, FunctionalarchitecturePackage.FUNCTIONAL_INPUT__INCOMING_LINKS, FunctionalInput.class, msgs); + return basicSetTo((FunctionalInput)otherEnd, msgs); + } + return super.eInverseAdd(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) { + switch (featureID) { + case FunctionalarchitecturePackage.INFORMATION_LINK__FROM: + return basicSetFrom(null, msgs); + case FunctionalarchitecturePackage.INFORMATION_LINK__TO: + return basicSetTo(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) { + switch (eContainerFeatureID()) { + case FunctionalarchitecturePackage.INFORMATION_LINK__FROM: + return eInternalContainer().eInverseRemove(this, FunctionalarchitecturePackage.FUNCTIONAL_OUTPUT__OUTGOING_LINKS, FunctionalOutput.class, msgs); + } + return super.eBasicRemoveFromContainerFeature(msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) { + switch (featureID) { + case FunctionalarchitecturePackage.INFORMATION_LINK__FROM: + return getFrom(); + case FunctionalarchitecturePackage.INFORMATION_LINK__TO: + if (resolve) return getTo(); + return basicGetTo(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) { + switch (featureID) { + case FunctionalarchitecturePackage.INFORMATION_LINK__FROM: + setFrom((FunctionalOutput)newValue); + return; + case FunctionalarchitecturePackage.INFORMATION_LINK__TO: + setTo((FunctionalInput)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.INFORMATION_LINK__FROM: + setFrom((FunctionalOutput)null); + return; + case FunctionalarchitecturePackage.INFORMATION_LINK__TO: + setTo((FunctionalInput)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) { + switch (featureID) { + case FunctionalarchitecturePackage.INFORMATION_LINK__FROM: + return getFrom() != null; + case FunctionalarchitecturePackage.INFORMATION_LINK__TO: + return to != null; + } + return super.eIsSet(featureID); + } + +} //InformationLinkImpl -- cgit v1.2.3-70-g09d2