/**
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.tuscany.sdo.impl;
import java.util.List;
import org.apache.tuscany.sdo.SDOFactory;
import org.apache.tuscany.sdo.util.BasicSequence;
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.EObject;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.util.BasicFeatureMap;
import org.eclipse.emf.ecore.util.EDataTypeEList;
import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
import org.eclipse.emf.ecore.util.EObjectContainmentEList;
import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
import org.eclipse.emf.ecore.util.EObjectEList;
import org.eclipse.emf.ecore.util.EObjectResolvingEList;
import org.eclipse.emf.ecore.util.EObjectWithInverseEList;
import org.eclipse.emf.ecore.util.EObjectWithInverseResolvingEList;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.FeatureMap;
import org.eclipse.emf.ecore.util.InternalEList;
import commonj.sdo.Sequence;
import commonj.sdo.Type;
/**
* Base implementation of the SDO DataObject interface. Used as base class for generated (static) SDO classes
*/
public abstract class DataObjectBase extends DataObjectImpl
{
protected int OPPOSITE_FEATURE_BASE = EOPPOSITE_FEATURE_BASE;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Following methods should be proposed SPI for generated subclasses to use
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected boolean isNotifying()
{
return changeRecorder != null;
}
protected interface ChangeKind
{
int SET = Notification.SET;
int UNSET = Notification.UNSET;
int RESOLVE = Notification.RESOLVE;
}
protected void notify(int changeKind, int property, Object oldValue, Object newValue)
{
eNotify(new ENotificationImpl(this, Notification.SET, property, oldValue, newValue));
}
protected void notify(int changeKind, int property, Object oldValue, Object newValue, boolean isSetChange)
{
eNotify(new ENotificationImpl(this, Notification.SET, property, oldValue, newValue, isSetChange));
}
protected void notify(int changeKind, int property, double oldDoubleValue, double newDoubleValue, boolean isSetChange)
{
eNotify(new ENotificationImpl(this, Notification.SET, property, oldDoubleValue, newDoubleValue, isSetChange));
}
protected void notify(int changeKind, int property, boolean oldBooleanValue, boolean newBooleanValue, boolean isSetChange)
{
eNotify(new ENotificationImpl(this, Notification.SET, property, oldBooleanValue, newBooleanValue, isSetChange));
}
public interface ListKind
{
int CONTAINMENT = 0;
int CONTAINMENT_UNSETTABLE = 1;
int CONTAINMENT_RESOLVING = 2;
int CONTAINMENT_RESOLVING_UNSETTABLE = 3;
int CONTAINMENT_INVERSE = 4;
int CONTAINMENT_INVERSE_UNSETTABLE = 5;
int CONTAINMENT_INVERSE_RESOLVING = 6;
int CONTAINMENT_INVERSE_RESOLVING_UNSETTABLE = 7;
int NONCONTAINMENT = 8;
int NONCONTAINMENT_UNSETTABLE = 9;
int NONCONTAINMENT_RESOLVING = 10;
int NONCONTAINMENT_RESOLVING_UNSETTABLE = 11;
int NONCONTAINMENT_INVERSE = 12;
int NONCONTAINMENT_INVERSE_UNSETTABLE = 13;
int NONCONTAINMENT_MANYINVERSE = 14;
int NONCONTAINMENT_MANYINVERSE_UNSETTABLE = 15;
int NONCONTAINMENT_INVERSE_RESOLVING = 16;
int NONCONTAINMENT_INVERSE_RESOLVING_UNSETTABLE = 17;
int NONCONTAINMENT_MANYINVERSE_RESOLVING = 18;
int NONCONTAINMENT_MANYINVERSE_RESOLVING_UNSETTABLE = 19;
int DATATYPE = 20;
int DATATYPE_UNSETTABLE = 21;
int DATATYPE_UNIQUE = 22;
int DATATYPE_UNIQUE_UNSETTABLE = 23;
int BASIC = 24;
}
/**
* @deprecated
*/
protected List createPropertyList(int listKind, Class dataClass, int property)
{
return createPropertyList(listKind, dataClass, property, 0);
}
protected List createPropertyList(int listKind, Class dataClass, int property, int reverseProperty)
{
switch (listKind)
{
case ListKind.CONTAINMENT:
return new EObjectContainmentEList(dataClass, this, property);
case ListKind.CONTAINMENT_INVERSE_RESOLVING_UNSETTABLE:
return new EObjectContainmentWithInverseEList.Unsettable.Resolving(dataClass, this, property, reverseProperty);
case ListKind.CONTAINMENT_INVERSE_RESOLVING:
return new EObjectContainmentWithInverseEList.Resolving(dataClass, this, property, reverseProperty);
case ListKind.CONTAINMENT_INVERSE_UNSETTABLE:
return new EObjectContainmentWithInverseEList.Unsettable(dataClass, this, property, reverseProperty);
case ListKind.CONTAINMENT_INVERSE:
return new EObjectContainmentWithInverseEList(dataClass, this, property, reverseProperty);
case ListKind.CONTAINMENT_RESOLVING_UNSETTABLE:
return new EObjectContainmentEList.Unsettable.Resolving(dataClass, this, property);
case ListKind.CONTAINMENT_RESOLVING:
return new EObjectContainmentEList.Resolving(dataClass, this, property);
case ListKind.CONTAINMENT_UNSETTABLE:
return new EObjectContainmentEList.Unsettable(dataClass, this, property);
case ListKind.NONCONTAINMENT_MANYINVERSE_RESOLVING_UNSETTABLE:
return new EObjectWithInverseResolvingEList.Unsettable.ManyInverse(dataClass, this, property, reverseProperty);
case ListKind.NONCONTAINMENT_MANYINVERSE_RESOLVING:
return new EObjectWithInverseResolvingEList.ManyInverse(dataClass, this, property, reverseProperty);
case ListKind.NONCONTAINMENT_INVERSE_RESOLVING_UNSETTABLE:
return new EObjectWithInverseResolvingEList.Unsettable(dataClass, this, property, reverseProperty);
case ListKind.NONCONTAINMENT_INVERSE_RESOLVING:
return new EObjectWithInverseResolvingEList(dataClass, this, property, reverseProperty);
case ListKind.NONCONTAINMENT_MANYINVERSE_UNSETTABLE:
return new EObjectWithInverseEList.Unsettable.ManyInverse(dataClass, this, property, reverseProperty);
case ListKind.NONCONTAINMENT_MANYINVERSE:
return new EObjectWithInverseEList.ManyInverse(dataClass, this, property, reverseProperty);
case ListKind.NONCONTAINMENT_INVERSE_UNSETTABLE:
return new EObjectWithInverseEList.Unsettable(dataClass, this, property, reverseProperty);
case ListKind.NONCONTAINMENT_INVERSE:
return new EObjectWithInverseEList(dataClass, this, property, reverseProperty);
case ListKind.NONCONTAINMENT_RESOLVING_UNSETTABLE:
return new EObjectResolvingEList.Unsettable(dataClass, this, property);
case ListKind.NONCONTAINMENT_RESOLVING:
return new EObjectResolvingEList(dataClass, this, property);
case ListKind.NONCONTAINMENT_UNSETTABLE:
return new EObjectEList.Unsettable(dataClass, this, property);
case ListKind.NONCONTAINMENT:
return new EObjectEList(dataClass, this, property);
case ListKind.DATATYPE_UNIQUE_UNSETTABLE:
return new EDataTypeUniqueEList.Unsettable(dataClass, this, property);
case ListKind.DATATYPE_UNIQUE:
return new EDataTypeUniqueEList(dataClass, this, property);
case ListKind.DATATYPE_UNSETTABLE:
return new EDataTypeEList.Unsettable(dataClass, this, property);
case ListKind.DATATYPE:
return new EDataTypeEList(dataClass, this, property);
}
return null;
}
protected BasicSequence createSequence(int property) {
return new BasicSequence(new BasicFeatureMap(this, property));
}
protected Sequence createSequence(Sequence sequence, Type type, int propertyIndex) {
return new BasicSequence((FeatureMap.Internal)((FeatureMap.Internal.Wrapper)sequence).featureMap().list(((EClass)type).getEStructuralFeature(propertyIndex)));
}
protected void createChangeSummary(int property) {
ChangeSummaryImpl changeSummary = (ChangeSummaryImpl)SDOFactory.eINSTANCE.createChangeSummary();
set(property, changeSummary);
changeSummary.setDataObject(this);
}
/*
* get the value of the type's property at propertyIndex via the sequence
* @param seq
* @param type
* @param propertyIndex
* @return
*/
protected Object get(Sequence seq, Type type, int propertyIndex) {
return ((FeatureMap.Internal.Wrapper)seq).featureMap().get(((EClass)type).getEStructuralFeature(propertyIndex), true);
}
protected List getList(Sequence seq, Type type, int propertyIndex) {
return ((FeatureMap.Internal.Wrapper)seq).featureMap().list(((EClass)type).getEStructuralFeature(propertyIndex));
}
protected void set(Sequence seq, Type type, int propertyIndex, Object newValue) {
((FeatureMap.Internal)((FeatureMap.Internal.Wrapper)seq).featureMap()).set(((EClass)type).getEStructuralFeature(propertyIndex), newValue);
}
protected void unset(Sequence seq, Type type, int propertyIndex) {
((FeatureMap.Internal)((FeatureMap.Internal.Wrapper)seq).featureMap()).clear(((EClass)type).getEStructuralFeature(propertyIndex));
}
protected boolean isSet(Sequence seq, Type type, int propertyIndex) {
return !((FeatureMap.Internal)((FeatureMap.Internal.Wrapper)seq).featureMap()).isEmpty(((EClass)type).getEStructuralFeature(propertyIndex));
}
protected boolean isSequenceEmpty(Sequence sequence) {
return ((FeatureMap.Internal.Wrapper)sequence).featureMap().isEmpty();
}
protected void setSequence(Sequence seq, Object newValue) {
((FeatureMap.Internal)((FeatureMap.Internal.Wrapper)seq).featureMap()).set(newValue);
}
protected void unsetSequence(Sequence seq) {
((FeatureMap.Internal.Wrapper)seq).featureMap().clear();
}
protected ChangeContext basicAdd(Sequence seq, Type type, int propertyIndex, Object newValue, ChangeContext changeContext) {
ChangeContextImpl changeContextImpl = (ChangeContextImpl)changeContext;
changeContextImpl.notificationChain = ((FeatureMap.Internal)((FeatureMap.Internal.Wrapper)seq).featureMap()).basicAdd(((EClass)type).getEStructuralFeature(propertyIndex), newValue, changeContextImpl.notificationChain);
return changeContextImpl;
}
protected Object get(int featureID, boolean resolve)
{
return null;
}
private ChangeContextImpl initializeChangeContext(ChangeContext changeContext)
{
ChangeContextImpl changeContextImpl;
if (changeContext == null)
{
changeContextImpl = new ChangeContextImpl(null);
} else
{
changeContextImpl = (ChangeContextImpl)changeContext;
}
return changeContextImpl;
}
protected interface ChangeContext {}
protected ChangeContext inverseRemove(Object otherEnd, int propertyIndex, ChangeContext changeContext)
{
ChangeContextImpl changeContextImpl = initializeChangeContext(changeContext);
changeContextImpl.notificationChain = super.eInverseRemove((InternalEObject)otherEnd, propertyIndex, changeContextImpl.notificationChain);
return changeContextImpl;
}
protected ChangeContext inverseAdd(Object otherEnd, int propertyIndex, ChangeContext changeContext)
{
ChangeContextImpl changeContextImpl = initializeChangeContext(changeContext);
changeContextImpl.notificationChain = super.eInverseAdd((InternalEObject)otherEnd, propertyIndex, changeContextImpl.notificationChain);
return changeContextImpl;
}
protected ChangeContext inverseRemove(Object thisEnd, Object otherEnd, int propertyIndex, Class baseClass, ChangeContext changeContext)
{
ChangeContextImpl changeContextImpl = initializeChangeContext(changeContext);
changeContextImpl.notificationChain = ((InternalEObject)thisEnd).eInverseRemove((InternalEObject)otherEnd, propertyIndex, baseClass, changeContextImpl.notificationChain);
return changeContextImpl;
}
protected ChangeContext inverseAdd(Object thisEnd, Object otherEnd, int propertyIndex, Class baseClass, ChangeContext changeContext)
{
ChangeContextImpl changeContextImpl = initializeChangeContext(changeContext);
changeContextImpl.notificationChain = ((InternalEObject)thisEnd).eInverseAdd((InternalEObject)otherEnd, propertyIndex, baseClass, changeContextImpl.notificationChain);
return changeContextImpl;
}
protected ChangeContext addNotification(Object notifier, int eventType, int featureID, Object oldValue, Object newValue, boolean isSetChanged, ChangeContext changeContext)
{
ENotificationImpl notification = new ENotificationImpl((InternalEObject)notifier, eventType, featureID, oldValue, newValue, isSetChanged );
ChangeContextImpl changeContextImpl = initializeChangeContext(changeContext);
if (changeContextImpl.notificationChain == null) changeContextImpl.notificationChain = notification; else changeContextImpl.notificationChain.add(notification);
return changeContextImpl;
}
protected ChangeContext addNotification(Object notifier, int eventType, int featureID, Object oldValue, Object newValue, ChangeContext changeContext)
{
ENotificationImpl notification = new ENotificationImpl((InternalEObject)notifier, eventType, featureID, oldValue, newValue);
ChangeContextImpl changeContextImpl = initializeChangeContext(changeContext);
if (changeContextImpl.notificationChain == null) changeContextImpl.notificationChain = notification; else changeContextImpl.notificationChain.add(notification);
return changeContextImpl;
}
protected ChangeContext removeFromList(List propertyList, Object objectToRemove, ChangeContext changeContext)
{
ChangeContextImpl changeContextImpl = initializeChangeContext(changeContext);
changeContextImpl.notificationChain = ((InternalEList)propertyList).basicRemove(objectToRemove, changeContextImpl.notificationChain);
return changeContextImpl;
}
protected ChangeContext removeFromSequence(Sequence sequence, Object otherEnd, ChangeContext changeContext)
{
ChangeContextImpl changeContextImpl = initializeChangeContext(changeContext);
changeContextImpl.notificationChain = ((InternalEList)((FeatureMap.Internal.Wrapper)sequence).featureMap()).basicRemove(otherEnd, changeContextImpl.notificationChain);
return changeContextImpl;
}
protected void dispatch(ChangeContext changeContext)
{
ChangeContextImpl changeContextImpl = initializeChangeContext(changeContext);
if (changeContextImpl.notificationChain != null)
{
changeContextImpl.notificationChain.dispatch();
}
}
protected boolean isProxy() // FB TODO : regen models and then remove this method
{
return eIsProxy();
}
protected boolean isProxy(Object object)
{
return ((EObject)object).eIsProxy();
}
protected Object resolveProxy(Object proxy)
{
return EcoreUtil.resolve((EObject)proxy, this);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Following methods override EMF methods to work with pure SDO generated subclasses
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public EClass eStaticClass()
{
return (EClass)getType();
}
public Type getType() // must be overridem in subclasses
{
throw new UnsupportedOperationException();
}
protected int internalConvertIndex(int internalIndex)
{
return internalIndex;
}
public Object eGet(int featureID, boolean resolve, boolean coreType)
{
Object result = get(internalConvertIndex(featureID), resolve);
if (coreType)
{
if (result instanceof FeatureMap.Internal.Wrapper) result = ((FeatureMap.Internal.Wrapper)result).featureMap();
}
return result;
}
public void eSet(int featureID, Object newValue)
{
set(internalConvertIndex(featureID), newValue);
}
public void eUnset(int featureID)
{
unset(internalConvertIndex(featureID));
}
public boolean eIsSet(int featureID)
{
return isSet(internalConvertIndex(featureID));
}
private class ChangeContextImpl implements ChangeContext
{
protected NotificationChain notificationChain;
public ChangeContextImpl(NotificationChain notificationChain) {
this.notificationChain = notificationChain;
}
}
//FB TODO ... review this? ... what about eInverseAdd?
public NotificationChain eInverseRemove(InternalEObject otherEnd, int propertyNumber, NotificationChain msgs)
{
return ((ChangeContextImpl)inverseRemove(otherEnd, propertyNumber, new ChangeContextImpl(msgs))).notificationChain;
}
public String toString()
{
StringBuffer result = new StringBuffer(getClass().getName());
result.append('@');
result.append(Integer.toHexString(hashCode()));
if (eIsProxy())
{
result.append(" (proxyURI: ");
result.append(eProxyURI());
result.append(')');
}
return result.toString();
}
} //DataObjectBase