path: root/sdo-java/branches/emf-2.5/impl/src/main/java/org/apache/tuscany/sdo/impl/ClassImpl.java

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