diff options
Diffstat (limited to 'sdo-java/branches/emf-2.5/impl/src/main/java/org/apache/tuscany/sdo/impl/ClassImpl.java')
| -rw-r--r-- | sdo-java/branches/emf-2.5/impl/src/main/java/org/apache/tuscany/sdo/impl/ClassImpl.java | 1049 |
1 files changed, 1049 insertions, 0 deletions
diff --git a/sdo-java/branches/emf-2.5/impl/src/main/java/org/apache/tuscany/sdo/impl/ClassImpl.java b/sdo-java/branches/emf-2.5/impl/src/main/java/org/apache/tuscany/sdo/impl/ClassImpl.java new file mode 100644 index 0000000000..d49ba2bf19 --- /dev/null +++ b/sdo-java/branches/emf-2.5/impl/src/main/java/org/apache/tuscany/sdo/impl/ClassImpl.java @@ -0,0 +1,1049 @@ +/** + * + * 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.EPackage; +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; +import java.lang.Class; + +/** + * <!-- 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 --> + */ + public Class getInstanceClass() { + // TODO verify!!! + return super.getInstanceClass(); + } + + /** + * <!-- 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 static final EStructuralFeature UNINITIALIZED_SEQUENCE_FEATURE = (EAttribute) SDOFactory.eINSTANCE + .createAttribute(); + protected static final EStructuralFeature VIRTUAL_SEQUENCE_FEATURE = (EAttribute) SDOFactory.eINSTANCE + .createAttribute(); + + private EStructuralFeature sequenceFeature = UNINITIALIZED_SEQUENCE_FEATURE; + + public EStructuralFeature getSequenceFeature() { + if (sequenceFeature == UNINITIALIZED_SEQUENCE_FEATURE) { + EStructuralFeature sequenceFeatureCandidate = null; + boolean hasNonDerivedFeatures = false; + + for (Iterator iterator = getEAllStructuralFeatures().iterator(); iterator + .hasNext();) { + EStructuralFeature eStructuralFeature = (EStructuralFeature) iterator + .next(); + if (!eStructuralFeature.isDerived()) { + if (sequenceFeatureCandidate == null + && isSequenceFeatureMap(eStructuralFeature)) + sequenceFeatureCandidate = eStructuralFeature; + else if (isElementFeature(eStructuralFeature) + && !DataObjectUtil + .isInternalProperty(eStructuralFeature)) + hasNonDerivedFeatures = true; + } + } + + sequenceFeature = sequenceFeatureCandidate != null + && hasNonDerivedFeatures ? VIRTUAL_SEQUENCE_FEATURE + : sequenceFeatureCandidate; + } + + return sequenceFeature; + } + + protected boolean isSequenceFeatureMap(EStructuralFeature eStructuralFeature) { + switch (ExtendedMetaData.INSTANCE.getFeatureKind(eStructuralFeature)) { + case ExtendedMetaData.ELEMENT_WILDCARD_FEATURE: + return eStructuralFeature.getUpperBound() != 1; + case ExtendedMetaData.GROUP_FEATURE: + return true; + } + return false; + } + + protected boolean isElementFeature(EStructuralFeature eStructuralFeature) { + switch (ExtendedMetaData.INSTANCE.getFeatureKind(eStructuralFeature)) { + case ExtendedMetaData.ATTRIBUTE_FEATURE: + case ExtendedMetaData.ATTRIBUTE_WILDCARD_FEATURE: + return false; + } + return true; + } + + public List getVirtualSequenceProperties() { + List result = new ArrayList(); + for (Iterator iterator = getEAllStructuralFeatures().iterator(); iterator + .hasNext();) { + EStructuralFeature eStructuralFeature = (EStructuralFeature) iterator + .next(); + if (!eStructuralFeature.isDerived() + && isElementFeature(eStructuralFeature)) + result.add(eStructuralFeature); + } + return result; + } + + 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 (allExtendedProperties == 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; + } + + /** + * Returns whether the object is an instance of this classifier. + * Overridden because it does not use dynamicInstance check in Tuscany. + * @param object the object in question. + * @return whether the object is an instance. + * @see Class#isInstance + */ + public boolean isInstance(Object object) + { + if (object != null) + { + Class<?> instanceClass = getInstanceClass(); + if (instanceClass != null) + { + if (instanceClass.isPrimitive()) + { + if (instanceClass == Boolean.TYPE) + { + return object instanceof Boolean; + } + else if (instanceClass == Integer.TYPE) + { + return object instanceof Integer; + } + else if (instanceClass == Float.TYPE) + { + return object instanceof Float; + } + else if (instanceClass == Byte.TYPE) + { + return object instanceof Byte; + } + else if (instanceClass == Character.TYPE) + { + return object instanceof Character; + } + else if (instanceClass == Double.TYPE) + { + return object instanceof Double; + } + else if (instanceClass == Short.TYPE) + { + return object instanceof Short; + } + else if (instanceClass == Long.TYPE) + { + return object instanceof Long; + } + } + else + { + return instanceClass.isInstance(object); + } + } + else if (object instanceof EObject) + { + return dynamicIsInstance((EObject)object); + } + } + + return false; + } + + // /////////////////////////////////////////////////////////////////////////////////////////////////////// + // 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 |