import org.eclipse.emf.ecore.EAnnotation;

  private EAttribute derivedEmployeeName;

    ts.addTest(new SimpleModelTest("testDerivedAttributes"));

    derivedEmployeeName = ecoreFactory.createEAttribute();

    derivedEmployeeName.setName("derivedName");

    derivedEmployeeName.setEType(ecorePackage.getEString());

    derivedEmployeeName.setDerived(true);

    derivedEmployeeName.setTransient(true);

    EAnnotation eAnnotation = ecoreFactory.createEAnnotation();

    eAnnotation.setSource(EcorePackage.eNS_URI);

    eAnnotation.getDetails().put("settingDelegate", "xxx");

    eAnnotation.getDetails().put("path", "name");

    derivedEmployeeName.getEAnnotations().add(eAnnotation);

    employeeClass.getEStructuralFeatures().add(derivedEmployeeName);

  public void testDerivedAttributes()

  {

    EFactory companyFactory = companyPackage.getEFactoryInstance();

    EObject employee1 = companyFactory.create(employeeClass);

    employee1.eSet(employeeName, "John");

    assertEquals("John", employee1.eGet(derivedEmployeeName));

    assertEquals(Boolean.FALSE, employee1.eGet(employeeManager));

    EObject employee2 = companyFactory.create(employeeClass);

    employee2.eSet(derivedEmployeeName, "Katherine");

    assertEquals("Katherine", employee2.eGet(employeeName));

    employee2.eSet(employeeManager, Boolean.TRUE);

    assertEquals(Boolean.TRUE, employee2.eGet(employeeManager));

  }

import org.eclipse.emf.ecore.util.EcoreUtil;

  protected Map<EClass, Boolean> suppressedAssociations;

    if (Boolean.TRUE.equals(options.get(XMLResource.OPTION_SUPPRESS_ASSOCIATION)))

    {

      suppressedAssociations = new HashMap<EClass, Boolean>();

    }

    protected Set<EStructuralFeature> nonTransientFeatures;

    public void setNotTransient(EStructuralFeature eStructuralFeature)

    {

      if (nonTransientFeatures == null)

      {

        nonTransientFeatures = new HashSet<EStructuralFeature>();

      }

      nonTransientFeatures.add(eStructuralFeature);

    }

import org.eclipse.emf.ecore.EcorePackage;

import org.eclipse.emf.ecore.util.EcoreUtil;

import org.eclipse.emf.ecore.EReference;

import org.eclipse.emf.ecore.EStructuralFeature;

import org.eclipse.emf.common.util.BasicEMap;

import org.eclipse.emf.ecore.util.PathSettingDelegate;

  protected Map<EClass, LinkRecord> linkClasses;

  protected Map<EReference, EReference> linkEnds;

    if (Boolean.TRUE.equals(options.get(XMLResource.OPTION_SUPPRESS_ASSOCIATION)))

    {

      linkClasses = new HashMap<EClass, LinkRecord>();

      linkEnds = new HashMap<EReference, EReference>();

    }

      boolean checkContains = false;

      EObject addedObject = object;

      if (linkClasses != null)

      {

        LinkRecord linkRecord = linkClasses.get(object.eClass());

        if (linkRecord != null && linkRecord.instance != null)

        {

          addedObject = linkRecord.instance;

          checkContains = true;

        }

      }

  protected static class LinkRecord

  {

    public EClass association;

    public EReference endA;

    public EReference mapA;

    public EReference endB;

    public EReference mapB;

    public EMap<EObject, Object> eMapA;

    public EMap<EObject, Object> eMapB;

    public Map<Object, BasicEMap.Entry<EObject, Object>> mapEntriesA = new HashMap<Object, BasicEMap.Entry<EObject,Object>>();

    public Map<Object, BasicEMap.Entry<EObject, Object>> mapEntriesB = new HashMap<Object, BasicEMap.Entry<EObject,Object>>();

    public EObject instance;

    public static final LinkRecord NONE = new LinkRecord();

  }

        if (linkClasses != null)

        {

          EClass eClass = newObject.eClass();

          LinkRecord linkRecord = linkClasses.get(eClass);

          if (linkRecord == null)

          {

            if ("true".equals(EcoreUtil.getAnnotation(eClass, EcorePackage.eNS_URI, "link")))

            {

              linkRecord = new LinkRecord();

              linkClasses.put(eClass, linkRecord);

              int count = 0;

              for (EReference eReference : eClass.getEReferences())

              {

                EClass eReferenceType = eReference.getEReferenceType();

                if ("java.util.Map$Entry".equals(eReferenceType.getInstanceClassName()))

                {

                  if (linkRecord.mapA == null)

                  {

                    linkRecord.mapA = eReference;

                  }

                  else

                  {

                    linkRecord.mapB = eReference;

                  }

                  if (linkRecord.association == null)

                  {

                    LOOP:

                    for (EClassifier eClassifier : eClass.getEPackage().getEClassifiers())

                    {

                      if (eClassifier != eClass && eClassifier instanceof EClass)

                      {

                        EClass otherEClass = (EClass)eClassifier;

                        for (EReference otherEReference : otherEClass.getEReferences())

                        {

                          if (otherEReference.getEType() == eReferenceType)

                          {

                            linkRecord.association = otherEClass;

                            linkRecord.instance = helper.createObject(otherEClass.getEPackage().getEFactoryInstance(), otherEClass);

                            break LOOP;

                          }

                        }

                      }

                    }

                  }

                  String name = eReference.getName() + "/";

                  for (EReference linkEndEReference : eClass.getEReferences())

                  {

                    String settingDelegate = EcoreUtil.getAnnotation(linkEndEReference, EcorePackage.eNS_URI, "settingDelegate");

                    String path = settingDelegate == null ? null : URI.createURI(settingDelegate).fragment();

                    if (path != null && path.startsWith(name))

                    {

                      if (linkRecord.endA == null)

                      {

                        linkRecord.endA = linkEndEReference;

                      }

                      else

                      {

                        linkRecord.endB = linkEndEReference;

                      }

                      break;

                    }

                  }

                  for (EReference otherEReference : linkRecord.association.getEReferences())

                  {

                    if (otherEReference.getEType() == eReferenceType)

                    {

                      if (linkRecord.eMapA == null)

                      {

                        linkRecord.eMapA = (EMap<EObject, Object>)linkRecord.instance.eGet(otherEReference);

                        linkEnds.put(linkRecord.endA, otherEReference);

                      }

                      else

                      {

                        linkRecord.eMapB = (EMap<EObject, Object>)linkRecord.instance.eGet(otherEReference);

                        linkEnds.put(linkRecord.endB, otherEReference);

                      }

                      break;

                    }

                  }

                  // featureTable.setNotTransient(eReference);

                  if (++count >= 2)

                  {

                    break;

                  }

                }

              }

            }

            else

            {

              linkClasses.put(eClass, LinkRecord.NONE);

            }

          }

        } 

      if (linkEnds != null)

      {

        EReference x = linkEnds.get(feature);

        if (x != null)

        {

          System.err.println("###" );

          LinkRecord linkRecord = linkClasses.get(object.eClass());

          InternalEObject eObjectValue = (InternalEObject)value;

          Object key = eObjectValue.eProxyURI();

          if (key == null)

          {

            key = value;

          }

          EClass mapEntryEClass = (linkRecord.endA == feature ? linkRecord.mapA : linkRecord.mapB).getEReferenceType();

          EMap<EObject, Object> eMap = linkRecord.endA == feature ? linkRecord.eMapA : linkRecord.eMapB;

          Map<Object, BasicEMap.Entry<EObject, Object>> map = linkRecord.endA == feature ? linkRecord.mapEntriesA : linkRecord.mapEntriesB;

          BasicEMap.Entry<EObject, Object> entry = map.get(key);

          if (entry == null)

          {

            entry = (BasicEMap.Entry<EObject, Object>)helper.createObject(mapEntryEClass.getEPackage().getEFactoryInstance(), mapEntryEClass);

            eMap.add(entry);

            map.put(key, entry);

          }

          entry.setKey(eObjectValue);

          if (mapEntryEClass.getEStructuralFeature("value").isMany())

          {

            ((List)entry.getValue()).add(object);

          }

          else

          {

            entry.setValue(object);

          }

          return;

        }

      }

  /**

   * @since 2.5

   */

  String OPTION_SUPPRESS_ASSOCIATION = "SUPPRESS_ASSOCIATION";

import java.io.Externalizable;

import java.io.IOException;

import java.io.ObjectInput;

import java.io.ObjectOutput;

import java.io.ObjectStreamException;

import java.io.Serializable;

import org.eclipse.emf.ecore.EPackage;

import org.eclipse.emf.ecore.util.FeatureMapUtil;

    protected static class WriteReplacement implements Externalizable

    {

      FeatureMap.Entry featureMapEntry;

      public WriteReplacement()

      {

        super();

      }

      public WriteReplacement(FeatureMap.Entry featureMapEntry)

      {

        this.featureMapEntry = featureMapEntry;

      }

      public void writeExternal(ObjectOutput out) throws IOException

      {

        EStructuralFeature eStructuralFeature = featureMapEntry.getEStructuralFeature();

        EClass eClass = eStructuralFeature.getEContainingClass();

        out.writeUTF(eClass.getEPackage().getNsURI());

        out.writeUTF(eClass.getName());

        out.writeUTF(eStructuralFeature.getName());

        out.writeObject(featureMapEntry.getValue());

      }

      public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException

      {

        EPackage ePackage = EPackage.Registry.INSTANCE.getEPackage(in.readUTF());

        EClass eClass = (EClass)ePackage.getEClassifier(in.readUTF());

        EStructuralFeature eStructuralFeature = eClass.getEStructuralFeature(in.readUTF());

        Object value = in.readObject();

        featureMapEntry = FeatureMapUtil.createRawEntry(eStructuralFeature, value);

      }

      private Object readResolve()

      {

        return featureMapEntry;

      }

    }

    public Object writeReplace() throws ObjectStreamException

    {

      return new WriteReplacement(this);

    }

/**

 * <copyright>

 *

 * Copyright (c) 2008 IBM Corporation and others.

 * All rights reserved.   This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors: 

 *   IBM - Initial API and implementation

 *

 * </copyright>

 *

 * $Id$

 */

package org.eclipse.emf.ecore.util;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.emf.common.util.URI;

import org.eclipse.emf.ecore.EClass;

import org.eclipse.emf.ecore.EObject;

import org.eclipse.emf.ecore.EStructuralFeature;

import org.eclipse.emf.ecore.EcorePackage;

import org.eclipse.emf.ecore.InternalEObject;

public class PathSettingDelegate extends BasicSettingDelegate.Stateless

{

  protected EStructuralFeature[] path;

  public PathSettingDelegate(EStructuralFeature eStructuralFeature)

  {

    super(eStructuralFeature);

    String namePath = URI.createURI(eStructuralFeature.getEAnnotation(EcorePackage.eNS_URI).getDetails().get("settingDelegate")).fragment();

    String[] segments = namePath.split("/");

    path = new EStructuralFeature[segments.length];

    for (int i = 0; i < segments.length; ++i)

    {

      String featureName = segments[i];

      EClass eClass = i == 0 ? eStructuralFeature.getEContainingClass() : (EClass)path[i - 1].getEType();

      path[i] = eClass.getEStructuralFeature(featureName);

    }

  }

  public PathSettingDelegate(EStructuralFeature eStructuralFeature, EStructuralFeature[] path)

  {

    super(eStructuralFeature);

    this.path = path;

  }

  @Override

  protected Object get(InternalEObject owner, boolean resolve, boolean coreType)

  {

    InternalEObject eObject = owner;

    for (int i = 0, limit = path.length - 1; i < limit; ++i)

    {

      EStructuralFeature feature = path[i];

      if (feature.isMany())

      {

        ArrayList<Object> result = new ArrayList<Object>();

        @SuppressWarnings("unchecked")

        List<EObject> elements = (List<EObject>)eObject.eGet(feature, resolve, coreType);

        for (EObject element : elements)

        {

          Object value = element.eGet(path[i + 1]);

          result.add(value);

        }

        return

          new EcoreEList.UnmodifiableEList.FastCompare<Object>

            (owner, eStructuralFeature, result.size(), result.toArray());

      }

      else

      {

        eObject = (InternalEObject)eObject.eGet(feature);

      }

    }

    return eObject.eGet(path[path.length - 1], resolve, coreType);

  }

  @Override

  protected boolean isSet(InternalEObject owner)

  {

    InternalEObject eObject = owner;

    for (int i = 0, limit = path.length - 1; i < limit; ++i)

    {

      eObject = (InternalEObject)eObject.eGet(path[i]);

    }

    return eObject.eIsSet(path[path.length - 1]);

  }

  @Override

  protected void set(InternalEObject owner, Object newValue)

  {

    InternalEObject eObject = owner;

    for (int i = 0, limit = path.length - 1; i < limit; ++i)

    {

      eObject = (InternalEObject)eObject.eGet(path[i]);

    }

    eObject.eSet(path[path.length - 1], newValue);

  }

  @Override

  protected void unset(InternalEObject owner)

  {

    InternalEObject eObject = owner;

    for (int i = 0, limit = path.length - 1; i < limit; ++i)

    {

      eObject = (InternalEObject)eObject.eGet(path[i]);

    }

    eObject.eUnset(path[path.length - 1]);

  }

}