| /** |
| * |
| * 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 |