/**
*
* 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.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.tuscany.sdo.SDOFactory;
import org.apache.tuscany.sdo.SDOPackage;
import org.apache.tuscany.sdo.model.ModelFactory;
import org.apache.tuscany.sdo.model.impl.ModelFactoryImpl;
import org.apache.tuscany.sdo.util.BasicSequence;
import org.apache.tuscany.sdo.util.DataObjectUtil;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.UniqueEList;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.impl.EClassImpl;
import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
import org.eclipse.emf.ecore.util.ExtendedMetaData;
import org.eclipse.emf.ecore.util.FeatureMap;
import org.eclipse.emf.ecore.util.FeatureMapUtil;
import commonj.sdo.Property;
import commonj.sdo.Sequence;
import commonj.sdo.Type;
/**
* <!-- begin-user-doc -->
* An implementation of the model object '<em><b>Class</b></em>'.
* <!-- end-user-doc -->
* <p>
* </p>
*
* @generated
*/
public class ClassImpl extends EClassImpl implements Type, org.apache.tuscany.sdo.model.Type/*, DataObject*/
{
private static final long serialVersionUID = 1L;
private static final Property UNINITIALIZED_PROPERTY = SDOFactory.eINSTANCE.createAttribute();
private Property changeSummaryPropertyCache = UNINITIALIZED_PROPERTY;
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
protected ClassImpl()
{
super();
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated NOT
*/
protected EClass eStaticClass()
{
return SDOPackage.eINSTANCE.getClass_();
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated NOT
*/
public String getURI()
{
return getEPackage().getNsURI();
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated NOT
*/
public boolean isDataType()
{
return false;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated NOT
*/
public boolean isOpen()
{
final List properties = getExtendedProperties();
if (properties != Collections.EMPTY_LIST)
{
for (int i = 0, count = properties.size(); i < count; ++i)
{
EStructuralFeature eStructuralFeature = (EStructuralFeature)properties.get(i);
if (isOpenFeatureMap(eStructuralFeature))
return true;
}
}
for (final Iterator iterator = getBaseTypes().iterator() ; iterator.hasNext(); )
{
Type baseType = (Type)iterator.next();
if (baseType.isOpen())
return true;
}
return false;
}
private EAttribute sequenceFeature = (EAttribute)UNINITIALIZED_PROPERTY;
public EAttribute getSequenceFeature()
{
//FB This isn't quite right.
//FB What if there are multiple sequences? We'll need to provide a mixed-like combined Sequence.
if (sequenceFeature == UNINITIALIZED_PROPERTY)
{
for (final Iterator iterator = getBaseTypes().iterator() ; iterator.hasNext(); )
{
ClassImpl baseType = (ClassImpl)iterator.next();
sequenceFeature = baseType.getSequenceFeature();
if (sequenceFeature != null) return sequenceFeature;
}
List properties = getExtendedProperties();
if (properties != Collections.EMPTY_LIST)
{
for (int i = 0, count = properties.size(); i < count; ++i)
{
EStructuralFeature eStructuralFeature = (EStructuralFeature)properties.get(i);
if (isSequenceFeatureMap(eStructuralFeature))
{
sequenceFeature = (EAttribute)eStructuralFeature;
return sequenceFeature;
}
}
}
sequenceFeature = null;
}
return sequenceFeature;
}
protected boolean isSequenceFeatureMap(EStructuralFeature eStructuralFeature)
{
//return eStructuralFeature == ExtendedMetaData.INSTANCE.getMixedFeature(this);
switch (ExtendedMetaData.INSTANCE.getFeatureKind(eStructuralFeature))
{
case ExtendedMetaData.ELEMENT_WILDCARD_FEATURE:
//return eStructuralFeature.getUpperBound() != 1; //FB TODO - I think this may be needed
int contentKind = ExtendedMetaData.INSTANCE.getContentKind(this);
return contentKind == ExtendedMetaData.MIXED_CONTENT || contentKind == ExtendedMetaData.SIMPLE_CONTENT;
case ExtendedMetaData.GROUP_FEATURE:
return true;
}
return false;
}
public void setSequenceFeature(EAttribute sequenceFeature)
{
getEStructuralFeatures().add(sequenceFeature);
this.sequenceFeature = sequenceFeature;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated NOT
*/
public boolean isSequenced()
{
return getSequenceFeature() != null;
}
protected List aliasNames = null;
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated NOT
*/
public List getAliasNames()
{
if (aliasNames == null)
{
aliasNames = DataObjectUtil.getAliasNames(this);
}
return aliasNames;
}
protected List declaredProperties = null;
public List getDeclaredProperties()
{
if (declaredProperties == null) {
initPropertyLists();
}
return declaredProperties;
}
protected List extendedProperties = null;
public List getExtendedProperties()
{
if (extendedProperties == null) {
initPropertyLists();
}
return extendedProperties;
}
protected List getTypeFeatures()
{
return getEStructuralFeatures();
}
protected void initPropertyLists()
{
List declaredProperties = new ArrayList();
List extendedProperties = Collections.EMPTY_LIST;
for (Iterator i = getTypeFeatures().iterator(); i.hasNext(); ) {
EStructuralFeature eStructuralFeature = (EStructuralFeature)i.next();
boolean isExtendedProperty = DataObjectUtil.isInternalProperty(eStructuralFeature);
if (isExtendedProperty) {
if (extendedProperties == Collections.EMPTY_LIST)
extendedProperties = new ArrayList();
extendedProperties.add(eStructuralFeature);
}
else
declaredProperties.add(eStructuralFeature);
}
this.declaredProperties = declaredProperties;
this.extendedProperties = extendedProperties;
}
public EList getEStructuralFeatures()
{
if (eStructuralFeatures == null)
{
eStructuralFeatures =
new EObjectContainmentWithInverseEList(EStructuralFeature.class, this, EcorePackage.ECLASS__ESTRUCTURAL_FEATURES, EcorePackage.ESTRUCTURAL_FEATURE__ECONTAINING_CLASS)
{
protected void didChange()
{
declaredProperties = extendedProperties = null;
}
};
}
return eStructuralFeatures;
}
protected List allProperties = null;
protected List allExtendedProperties = null;
protected EList allFeaturesCache = null;
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated NOT
*/
public List getProperties()
{
final EList allFeatures = getEAllStructuralFeatures();
if (allFeatures != allFeaturesCache)
{
allFeaturesCache = allFeatures;
allProperties = allExtendedProperties = null;
}
if (allProperties == null)
{
List allProperties = new UniqueEList();
for (final Iterator iterator = getBaseTypes().iterator(); iterator.hasNext(); )
{
Type baseType = (Type)iterator.next();
allProperties.addAll(baseType.getProperties());
}
allProperties.addAll(getDeclaredProperties());
this.allProperties = allProperties;
}
return allProperties;
}
public List getAllExtendedProperties()
{
final EList allFeatures = getEAllStructuralFeatures();
if (allFeatures != allFeaturesCache)
{
allFeaturesCache = allFeatures;
allProperties = allExtendedProperties = null;
}
if (allProperties == null)
{
List allExtendedProperties = new UniqueEList();
for (final Iterator iterator = getBaseTypes().iterator(); iterator.hasNext(); )
{
Type baseType = (Type)iterator.next();
allExtendedProperties.addAll(((ClassImpl)baseType).getAllExtendedProperties());
}
allExtendedProperties.addAll(getExtendedProperties());
this.allExtendedProperties = allExtendedProperties;
}
return allExtendedProperties;
}
protected boolean isOpenFeatureMap(EStructuralFeature eStructuralFeature)
{
switch (ExtendedMetaData.INSTANCE.getFeatureKind(eStructuralFeature))
{
case ExtendedMetaData.ELEMENT_WILDCARD_FEATURE:
return eStructuralFeature != ExtendedMetaData.INSTANCE.getMixedFeature(this);
case ExtendedMetaData.ATTRIBUTE_WILDCARD_FEATURE:
//FB I think this is wrong ... case ExtendedMetaData.GROUP_FEATURE:
return true;
}
return false;
}
public void addOpenProperties(EObject dataObject, Collection propertyList)
{
for (final Iterator iterator = getBaseTypes().iterator(); iterator.hasNext(); )
{
ClassImpl baseType = (ClassImpl)iterator.next();
baseType.addOpenProperties(dataObject, propertyList);
}
for (final Iterator iter = getExtendedProperties().iterator(); iter.hasNext(); )
{
EStructuralFeature eStructuralFeature = (EStructuralFeature)iter.next();
if (isOpenFeatureMap(eStructuralFeature))
{
List features = (List)dataObject.eGet(eStructuralFeature);
for (int j = 0, size = features.size(); j < size; ++j)
{
FeatureMap.Entry entry = (FeatureMap.Entry)features.get(j);
EStructuralFeature entryFeature = entry.getEStructuralFeature();
Property property = BasicSequence.getFeatureProperty(entryFeature);
if (property != null) propertyList.add(entryFeature);
}
}
}
}
public Property getOpenProperty(EObject dataObject, String featureName)
{
for (final Iterator iterator = getBaseTypes().iterator(); iterator.hasNext(); )
{
ClassImpl baseType = (ClassImpl)iterator.next();
Property result = baseType.getOpenProperty(dataObject, featureName);
if (result != null) return result;
}
Set openFeatureSet = new HashSet();
for (final Iterator iter = getExtendedProperties().iterator(); iter.hasNext(); )
{
EStructuralFeature eStructuralFeature = (EStructuralFeature)iter.next();
//if (isOpenFeatureMap(eStructuralFeature))
//FB The above check excludes subsitition groups - i.e., doesn't support dObj.get("element.substitution")
if (FeatureMapUtil.isFeatureMap(eStructuralFeature))
{
List features = (List)dataObject.eGet(eStructuralFeature);
for (int j = 0, size = features.size(); j < size; ++j)
{
FeatureMap.Entry entry = (FeatureMap.Entry)features.get(j);
EStructuralFeature entryFeature = entry.getEStructuralFeature();
if (openFeatureSet.add(entryFeature))
{
Property property = BasicSequence.getFeatureProperty(entryFeature);
if (property != null)
{
if (property.getName().equals(featureName)) return (Property)entryFeature;
List aliasNames = property.getAliasNames();
for (int aliasCount = aliasNames.size(); aliasCount > 0; )
{
if (aliasNames.get(--aliasCount).equals(featureName)) return (Property)entryFeature;
}
}
}
}
}
}
return null;
}
/*
public Property getOpenProperty(DataObject dataObject, String featureName)
{
EObject eObject = (EObject)dataObject;
EClass eClass = eObject.eClass();
Set openFeatureSet = new HashSet();
for (int i = 0, count = eClass.getEAllStructuralFeatures().size(); i < count; ++i)
{
EStructuralFeature eStructuralFeature = eClass.getEStructuralFeature(i);
if (FeatureMapUtil.isFeatureMap(eStructuralFeature))
{
List features = (List)eObject.eGet(eStructuralFeature);
for (int j = 0, size = features.size(); j < size; ++j)
{
FeatureMap.Entry entry = (FeatureMap.Entry)features.get(j);
EStructuralFeature entryFeature = entry.getEStructuralFeature();
if (openFeatureSet.add(entryFeature))
{
Property property = (Property)entryFeature;
if (property.getName().equals(featureName)) return (Property)entryFeature;
List aliasNames = property.getAliasNames();
for (int aliasCount = aliasNames.size(); aliasCount > 0; )
{
if (aliasNames.get(--aliasCount).equals(featureName)) return (Property)entryFeature;
}
}
}
}
}
return null;
}
*/
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated NOT
*/
public List getBaseTypes()
{
return getESuperTypes();
}
private void initAliasNames() {
Map result = new HashMap();
for (Iterator i = getProperties().iterator(); i.hasNext();)
{
Property property = (Property)i.next();
result.put(property.getName(), property);
List aliasNames = property.getAliasNames();
for (int count = aliasNames.size(); count > 0;)
{
result.put(aliasNames.get(--count), property);
}
}
propertyNameToPropertyMap = result;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated NOT
*/
public Property getProperty(String propertyName)
{
if (propertyNameToPropertyMap == null) initAliasNames();
Property property = (Property)propertyNameToPropertyMap.get(propertyName);
if (property == null && !isOpen()) {
initAliasNames();
property = (Property)propertyNameToPropertyMap.get(propertyName);
}
return property;
}
protected Map propertyNameToPropertyMap;
public List getInstanceProperties() {
return DataObjectUtil.getMetaObjectInstanceProperties(this);
}
public Object get(Property property) {
return DataObjectUtil.getMetaObjectInstanceProperty(this, property);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// org.apache.tuscany.sdo.model.Type method implementations
/////////////////////////////////////////////////////////////////////////////////////////////////////////
public List getBaseType() {
return this.getBaseTypes();
}
public List getProperty() {
return this.getProperties();
}
public List getAliasName() {
return this.getAliasNames();
}
public void unsetAbstract() {
eUnset(EcorePackage.eINSTANCE.getEClass_Abstract());
}
public boolean isSetAbstract() {
return eIsSet(EcorePackage.eINSTANCE.getEClass_Abstract());
}
public Sequence getAny() {
throw new UnsupportedOperationException();
}
public Sequence getAnyAttribute() {
throw new UnsupportedOperationException();
}
public void setDataType(boolean value) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public void unsetDataType() {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public boolean isSetDataType() {
return false;
}
public void setOpen(boolean value) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public void unsetOpen() {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public boolean isSetOpen() {
return isOpen();
}
public void setSequenced(boolean value) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public void unsetSequenced() {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public boolean isSetSequenced() {
return isSequenced();
}
public void unsetName()
{
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public boolean isSetName()
{
return true;
}
public void unsetUri()
{
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public boolean isSetUri()
{
return true;
}
public void setUri(String value) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public String getUri() {
return getURI();
}
public Property getChangeSummaryProperty() {
if (changeSummaryPropertyCache == UNINITIALIZED_PROPERTY) {
changeSummaryPropertyCache = null;
// Find property of type ChangeSummaryType, if one exists
Type csType = ((ModelFactoryImpl)ModelFactory.INSTANCE).getChangeSummaryType();
for (Iterator props = getProperties().iterator(); props.hasNext(); ) {
Property p = (Property)props.next();
if(csType == p.getType()) {
changeSummaryPropertyCache = p;
break;
}
}
}
return changeSummaryPropertyCache;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// DataObject method implementations
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
public Object get(int propertyIndex) {
return DataObjectUtil.get(this, propertyIndex);
}
public void set(int propertyIndex, Object value) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public boolean isSet(int propertyIndex) {
return DataObjectUtil.isSet(this, propertyIndex);
}
public void unset(int propertyIndex) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public Object get(Property property) {
return DataObjectUtil.get(this, ((EStructuralFeature)property).getFeatureID());
}
public void set(Property property, Object value) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public boolean isSet(Property property) {
return DataObjectUtil.isSet(this, ((EStructuralFeature)property).getFeatureID());
}
public void unset(Property property) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public DataObject getContainer() {
return (DataObject)eContainer();
}
public Property getContainmentProperty() {
return (Property)eContainmentFeature();
}
public Type getType() {
return (Type)ModelPackageImpl.eINSTANCE.getType();
}
// Remaining DataObject methods are (will be) implemented as straight delegation to DataObjectUtil
public Object get(String path) {
return DataObjectUtil.get(this, path);
}
public void set(String path, Object value) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public boolean isSet(String path) {
return DataObjectUtil.isSet(this, path);
}
public void unset(String path) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public boolean getBoolean(String path) {
return DataObjectUtil.getBoolean(get(path));
}
public byte getByte(String path) {
return DataObjectUtil.getByte(get(path));
}
public char getChar(String path) {
return DataObjectUtil.getChar(get(path));
}
public double getDouble(String path) {
return DataObjectUtil.getDouble(get(path));
}
public float getFloat(String path) {
return DataObjectUtil.getFloat(get(path));
}
public int getInt(String path) {
return DataObjectUtil.getInt(get(path));
}
public long getLong(String path) {
return DataObjectUtil.getLong(get(path));
}
public short getShort(String path) {
return DataObjectUtil.getShort(get(path));
}
public byte[] getBytes(String path) {
return DataObjectUtil.getBytes(get(path));
}
public BigDecimal getBigDecimal(String path) {
return DataObjectUtil.getBigDecimal(get(path));
}
public BigInteger getBigInteger(String path) {
return DataObjectUtil.getBigInteger(get(path));
}
public DataObject getDataObject(String path) {
return (DataObject)get(path);
}
public Date getDate(String path) {
return DataObjectUtil.getDate(get(path));
}
public String getString(String path) {
return DataObjectUtil.getString(get(path));
}
public List getList(String path) {
return (List)get(path);
}
public Sequence getSequence(String path) {
return (Sequence)get(path);
}
public void setBoolean(String path, boolean value) {
set(path, new Boolean(value));
}
public void setByte(String path, byte value) {
set(path, new Byte(value));
}
public void setChar(String path, char value) {
set(path, new Character(value));
}
public void setDouble(String path, double value) {
set(path, new Double(value));
}
public void setFloat(String path, float value) {
set(path, new Float(value));
}
public void setInt(String path, int value) {
set(path, new Integer(value));
}
public void setLong(String path, long value) {
set(path, new Long(value));
}
public void setShort(String path, short value) {
set(path, new Short(value));
}
public void setBytes(String path, byte[] value) {
set(path, value);
}
public void setBigDecimal(String path, BigDecimal value) {
set(path, value);
}
public void setBigInteger(String path, BigInteger value) {
set(path, value);
}
public void setDataObject(String path, DataObject value) {
set(path, value);
}
public void setDate(String path, Date value) {
set(path, value);
}
public void setString(String path, String value) {
set(path, value);
}
public void setList(String path, List value) {
set(path, value);
}
public boolean getBoolean(int propertyIndex) {
return DataObjectUtil.getBoolean(this, propertyIndex);
}
public byte getByte(int propertyIndex) {
return DataObjectUtil.getByte(this, propertyIndex);
}
public char getChar(int propertyIndex) {
return DataObjectUtil.getChar(this, propertyIndex);
}
public double getDouble(int propertyIndex) {
return DataObjectUtil.getDouble(this, propertyIndex);
}
public float getFloat(int propertyIndex) {
return DataObjectUtil.getFloat(this, propertyIndex);
}
public int getInt(int propertyIndex) {
return DataObjectUtil.getInt(this, propertyIndex);
}
public long getLong(int propertyIndex) {
return DataObjectUtil.getLong(this, propertyIndex);
}
public short getShort(int propertyIndex) {
return DataObjectUtil.getShort(this, propertyIndex);
}
public byte[] getBytes(int propertyIndex) {
return DataObjectUtil.getBytes(this, propertyIndex);
}
public BigDecimal getBigDecimal(int propertyIndex) {
return DataObjectUtil.getBigDecimal(this, propertyIndex);
}
public BigInteger getBigInteger(int propertyIndex) {
return DataObjectUtil.getBigInteger(this, propertyIndex);
}
public DataObject getDataObject(int propertyIndex) {
return DataObjectUtil.getDataObject(this, propertyIndex);
}
public Date getDate(int propertyIndex) {
return DataObjectUtil.getDate(this, propertyIndex);
}
public String getString(int propertyIndex) {
return DataObjectUtil.getString(this, propertyIndex);
}
public List getList(int propertyIndex) {
return DataObjectUtil.getList(this, propertyIndex);
}
public Sequence getSequence(int propertyIndex) {
return DataObjectUtil.getSequence(this, propertyIndex);
}
public void setBoolean(int propertyIndex, boolean value) {
set(propertyIndex, new Boolean(value));
}
public void setByte(int propertyIndex, byte value) {
set(propertyIndex, new Byte(value));
}
public void setChar(int propertyIndex, char value) {
set(propertyIndex, new Character(value));
}
public void setDouble(int propertyIndex, double value) {
set(propertyIndex, new Double(value));
}
public void setFloat(int propertyIndex, float value) {
set(propertyIndex, new Float(value));
}
public void setInt(int propertyIndex, int value) {
set(propertyIndex, new Integer(value));
}
public void setLong(int propertyIndex, long value) {
set(propertyIndex, new Long(value));
}
public void setShort(int propertyIndex, short value) {
set(propertyIndex, new Short(value));
}
public void setBytes(int propertyIndex, byte[] value) {
set(propertyIndex, value);
}
public void setBigDecimal(int propertyIndex, BigDecimal value) {
set(propertyIndex, value);
}
public void setBigInteger(int propertyIndex, BigInteger value) {
set(propertyIndex, value);
}
public void setDataObject(int propertyIndex, DataObject value) {
set(propertyIndex, value);
}
public void setDate(int propertyIndex, Date value) {
set(propertyIndex, value);
}
public void setString(int propertyIndex, String value) {
set(propertyIndex, value);
}
public void setList(int propertyIndex, List value) {
set(propertyIndex, value);
}
public boolean getBoolean(Property property) {
return DataObjectUtil.getBoolean(this, property);
}
public byte getByte(Property property) {
return DataObjectUtil.getByte(this, property);
}
public char getChar(Property property) {
return DataObjectUtil.getChar(this, property);
}
public double getDouble(Property property) {
return DataObjectUtil.getDouble(this, property);
}
public float getFloat(Property property) {
return DataObjectUtil.getFloat(this, property);
}
public int getInt(Property property) {
return DataObjectUtil.getInt(this, property);
}
public long getLong(Property property) {
return DataObjectUtil.getLong(this, property);
}
public short getShort(Property property) {
return DataObjectUtil.getShort(this, property);
}
public byte[] getBytes(Property property) {
return DataObjectUtil.getBytes(this, property);
}
public BigDecimal getBigDecimal(Property property) {
return DataObjectUtil.getBigDecimal(this, property);
}
public BigInteger getBigInteger(Property property) {
return DataObjectUtil.getBigInteger(this, property);
}
public DataObject getDataObject(Property property) {
return DataObjectUtil.getDataObject(this, property);
}
public Date getDate(Property property) {
return DataObjectUtil.getDate(this, property);
}
public String getString(Property property) {
return DataObjectUtil.getString(this, property);
}
public List getList(Property property) {
return DataObjectUtil.getList(this, property);
}
public Sequence getSequence(Property property) {
return DataObjectUtil.getSequence(this, property);
}
public void setBoolean(Property property, boolean value) {
set(property, new Boolean(value));
}
public void setByte(Property property, byte value) {
set(property, new Byte(value));
}
public void setChar(Property property, char value) {
set(property, new Character(value));
}
public void setDouble(Property property, double value) {
set(property, new Double(value));
}
public void setFloat(Property property, float value) {
set(property, new Float(value));
}
public void setInt(Property property, int value) {
set(property, new Integer(value));
}
public void setLong(Property property, long value) {
set(property, new Long(value));
}
public void setShort(Property property, short value) {
set(property, new Short(value));
}
public void setBytes(Property property, byte[] value) {
set(property, value);
}
public void setBigDecimal(Property property, BigDecimal value) {
set(property, value);
}
public void setBigInteger(Property property, BigInteger value) {
set(property, value);
}
public void setDataObject(Property property, DataObject value) {
set(property, value);
}
public void setDate(Property property, Date value) {
set(property, value);
}
public void setString(Property property, String value) {
set(property, value);
}
public void setList(Property property, List value) {
set(property, value);
}
public DataObject createDataObject(String propertyName) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public DataObject createDataObject(int propertyIndex) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public DataObject createDataObject(Property property) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public DataObject createDataObject(String propertyName, String namespaceURI, String typeName) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public DataObject createDataObject(int propertyIndex, String namespaceURI, String typeName) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public DataObject createDataObject(Property property, Type type) {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public void delete() {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
}
public DataGraph getDataGraph() {
return DataObjectUtil.getDataGraph(this);
}
public Sequence getSequence() {
EAttribute mixedFeature = BasicExtendedMetaData.INSTANCE.getMixedFeature(eClass());
return mixedFeature != null ? (Sequence)eGet(mixedFeature, true, false) : null;
}
public List getInstanceProperties() {
return DataObjectUtil.getInstanceProperties(this);
}
public DataObject getRootObject() {
return DataObjectUtil.getRootObject(this);
}
public ChangeSummary getChangeSummary() {
// TODO: implement this method
throw new UnsupportedOperationException();
}
public void detach() {
throw new UnsupportedOperationException("Type is frozen and cannot be modified");
//DataObjectUtil.detach(this);
}
*/
} //ClassTypeImpl