/**
 *
 *  Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you under the Apache License, Version 2.0 (the
 *  "License"); you may not use this file except in compliance
 *  with the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing,
 *  software distributed under the License is distributed on an
 *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *  KIND, either express or implied.  See the License for the
 *  specific language governing permissions and limitations
 *  under the License.
 */
package org.apache.tuscany.sdo.impl;

import java.util.List;

import org.apache.tuscany.sdo.SDOPackage;
import org.apache.tuscany.sdo.util.DataObjectUtil;
import org.apache.tuscany.sdo.util.SDOUtil;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.impl.EReferenceImpl;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.ExtendedMetaData;

import commonj.sdo.Property;
import commonj.sdo.Sequence;
import commonj.sdo.Type;

/**
 * <!-- begin-user-doc -->
 * An implementation of the model object '<em><b>Reference</b></em>'.
 * <!-- end-user-doc -->
 * <p>
 * </p>
 *
 * @generated
 */
public class ReferenceImpl extends EReferenceImpl implements Property
{
  /**
	 * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
	 * @generated
	 */
  protected ReferenceImpl()
  {
		super();
	}

  /**
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   * @generated NOT
   */
  protected EClass eStaticClass()
  {
    return SDOPackage.eINSTANCE.getReference();
  }

  /**
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   * @generated NOT
   */
  public Object getDefault()
  {
    return getDefaultValue();
  }

  /**
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   * @generated NOT
   */
  public boolean isReadOnly()
  {
    //return "true".equals(EcoreUtil.getAnnotation(this, "commonj.sdo", "readOnly"));
    return !isChangeable(); //TODO semantics don't exactly match?
  }

  /**
   * Single-valued SDO properties behave as EMF unsettable, multi-valued properties as EMF !unsettable
   */
  public boolean isUnsettable()
  {
    return !isMany();
  }

  protected List aliasNames = null;

  /**
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   * @generated NOT
   */
  public List getAliasNames()
  {
    if (aliasNames == null)
    {
      aliasNames = DataObjectUtil.getAliasNames(this);
    }
    return aliasNames;
  }

  /**
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   * @generated NOT
   */
  public Type getType()
  {
    return (Type)getEType();
    /*
    EClassifier eType = getEType();
    //FB More temporary hacks
    return eType instanceof Type ? (Type)getEType() : null;
    */
  }

  /**
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   * @generated NOT
   */
  public Type getContainingType()
  {
    return (Type)getEContainingClass();
  }

  /**
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   * @generated NOT
   */
  public Property getOpposite()
  {
    return (Property)getEOpposite();
  }
  
  public boolean isNullable()
  {
    String isNillable = EcoreUtil.getAnnotation(this, ExtendedMetaData.ANNOTATION_URI, "nillable");
    return isNillable != null && "true".equals(isNillable);
  }

  public boolean isOpenContent()
  {
    return SDOUtil.isDocumentRoot(getContainingType());
  }

  public List getInstanceProperties() {
    return DataObjectUtil.getMetaObjectInstanceProperties(this);
  }

  public Object get(Property property) {
    return DataObjectUtil.getMetaObjectInstanceProperty(this, property);
  }
  
  /////////////////////////////////////////////////////////////////////////////////////////////////////////
  // org.apache.tuscany.sdo.model.Property methods
  /////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  public List getAliasName() {
    return this.getAliasNames();
  }

  public Sequence getAny() {
    throw new UnsupportedOperationException();
  }

  public void setMany(boolean value) {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public void unsetMany() {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public boolean isSetMany() {
    return isMany();
  }

  public void setReadOnly(boolean value) {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public void unsetReadOnly() {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public boolean isSetReadOnly() {
    return isReadOnly();
  }

  public org.apache.tuscany.sdo.model.Type getType_() {
    return (org.apache.tuscany.sdo.model.Type)getType();
  }

  public void setType(org.apache.tuscany.sdo.model.Type value) {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public Sequence getAnyAttribute() {
    throw new UnsupportedOperationException();
  }

  public String getDefault_() {
    return (String) this.getDefault();
  }

  public void setDefault_(String value) {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public org.apache.tuscany.sdo.model.Property getOpposite_() {
    return (org.apache.tuscany.sdo.model.Property) getOpposite();
  }

  public void setOpposite_(org.apache.tuscany.sdo.model.Property value) {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public void unsetContainment() {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public boolean isSetContainment() {
    return isContainment();
  }
  
  public void setNullable(boolean value) {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public void unsetNullable() {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public boolean isSetNullable() {
    return isNullable();
  }

  public void unsetName()
  {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public boolean isSetName()
  {
    return true;
  }
  
  public void unsetOpposite()
  {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public boolean isSetOpposite()
  {
    return getOpposite() != null;
  }
  
  public void unsetType()
  {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public boolean isSetType()
  {
    return true;
  }
  
  public void unsetDefault()
  {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public boolean isSetDefault()
  {
    return getDefault() != null;
  }
  
  
  /////////////////////////////////////////////////////////////////////////////////////////////////////////
  // DataObject method implementations
  /////////////////////////////////////////////////////////////////////////////////////////////////////////
  /*
  public Object get(int propertyIndex) {
    return DataObjectUtil.get(this, propertyIndex);
  }
  
  public void set(int propertyIndex, Object value) {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public boolean isSet(int propertyIndex) {
    return DataObjectUtil.isSet(this, propertyIndex);
  }

  public void unset(int propertyIndex) {
    throw new UnsupportedOperationException("Property 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("Property 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("Property is frozen and cannot be modified");
  }
  
  public DataObject getContainer() {
    return (DataObject)eContainer();
  }

  public Property getContainmentProperty() {
    return (Property)eContainmentFeature();
  }  

  // 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("Property is frozen and cannot be modified");
  }

  public boolean isSet(String path) {
    return DataObjectUtil.isSet(this, path);
  }

  public void unset(String path) {
    throw new UnsupportedOperationException("Property 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("Property is frozen and cannot be modified");
  }

  public DataObject createDataObject(int propertyIndex) {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public DataObject createDataObject(Property property) {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public DataObject createDataObject(String propertyName, String namespaceURI, String typeName) {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public DataObject createDataObject(int propertyIndex, String namespaceURI, String typeName) {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public DataObject createDataObject(Property property, Type type) {
    throw new UnsupportedOperationException("Property is frozen and cannot be modified");
  }

  public void delete() {
    throw new UnsupportedOperationException("Property 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("Property is frozen and cannot be modified");
    //DataObjectUtil.detach(this);
  }
  
  public Property getProperty(String propertyName) {
    return DataObjectUtil.getProperty(this, propertyName);
  }
  */
  
} //ReferenceImpl