ObjyObject.java

/*
 * Copyright (c) 2010-2013, 2015, 2016 Eike Stepper (Berlin, Germany) 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:
 *    Ibrahim Sallam - initial API and implementation
 */
package org.eclipse.emf.cdo.server.internal.objectivity.db;

import org.eclipse.emf.cdo.common.branch.CDOBranch;
import org.eclipse.emf.cdo.common.id.CDOID;
import org.eclipse.emf.cdo.common.id.CDOIDExternal;
import org.eclipse.emf.cdo.common.model.EMFUtil;
import org.eclipse.emf.cdo.common.revision.CDOList;
import org.eclipse.emf.cdo.common.revision.CDORevision;
import org.eclipse.emf.cdo.common.revision.CDORevisionUtil;
import org.eclipse.emf.cdo.common.util.CDOCommonUtil;
import org.eclipse.emf.cdo.server.internal.objectivity.ObjectivityStoreAccessor;
import org.eclipse.emf.cdo.server.internal.objectivity.bundle.OM;
import org.eclipse.emf.cdo.server.internal.objectivity.mapper.IManyTypeMapper;
import org.eclipse.emf.cdo.server.internal.objectivity.mapper.ISingleTypeMapper;
import org.eclipse.emf.cdo.server.internal.objectivity.mapper.ITypeMapper;
import org.eclipse.emf.cdo.server.internal.objectivity.mapper.ObjyMapper;
import org.eclipse.emf.cdo.server.internal.objectivity.mapper.SingleReferenceMapper;
import org.eclipse.emf.cdo.server.internal.objectivity.schema.ObjyArrayListId;
import org.eclipse.emf.cdo.server.internal.objectivity.schema.ObjyArrayListString;
import org.eclipse.emf.cdo.server.internal.objectivity.schema.ObjyBase;
import org.eclipse.emf.cdo.server.internal.objectivity.schema.ObjyFeatureMapArrayList;
import org.eclipse.emf.cdo.server.internal.objectivity.schema.ObjyFeatureMapEntry;
import org.eclipse.emf.cdo.server.internal.objectivity.schema.ObjyProxy;
import org.eclipse.emf.cdo.server.internal.objectivity.utils.OBJYCDOIDUtil;
import org.eclipse.emf.cdo.spi.common.revision.InternalCDOList;
import org.eclipse.emf.cdo.spi.common.revision.InternalCDORevision;

import org.eclipse.net4j.util.collection.MoveableList;
import org.eclipse.net4j.util.om.trace.ContextTracer;

import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.util.FeatureMap;

import com.objy.as.app.Class_Object;
import com.objy.as.app.Numeric_Value;
import com.objy.as.app.Relationship_Object;
import com.objy.as.app.String_Value;
import com.objy.as.app.VArray_Object;
import com.objy.as.app.d_Attribute;
import com.objy.as.app.d_Class;
import com.objy.as.app.d_Ref_Type;
import com.objy.db.app.ooId;
import com.objy.db.app.ooObj;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * @author Ibrahim Sallam
 */
public class ObjyObject
{
  private static final ContextTracer TRACER_DEBUG = new ContextTracer(OM.DEBUG, ObjyObject.class);

  protected Class_Object classObject;

  protected ObjyClass objyClass;

  protected Class_Object baseClassObject = null;

  protected Relationship_Object baseRel = null;

  protected boolean hasBaseRelationshipChecked = false;

  protected Relationship_Object revisionsRel = null;

  protected Relationship_Object lastRevisionRel = null;

  protected ooId objectId;

  protected ooId revisionId = null;

  protected int version = Integer.MAX_VALUE;

  public static int fetchCount = 0;

  public static int updateCount = 0;

  public static long createObjectTime = 0;

  public static int createObjectCount = 0;

  // protected boolean isRoot = false;

  // IS: for stats.
  // public static int count = 0;
  // public static long tDiff = 0;

  // good for fast access.
  // private Map<Class_Position, Object> featureMap = new HashMap<Class_Position, Object>();
  private Map<String, Object> featureMap = new HashMap<String, Object>();

  public ObjyObject(Class_Object classObject)
  {
    // long tStart = System.currentTimeMillis();

    this.classObject = classObject;
    d_Class dClass = classObject.type_of();
    String fullyQualifiedClassName = null;

    try
    {

      if (dClass.namespace_name() != null)
      {
        fullyQualifiedClassName = dClass.namespace_name() + ":" + dClass.name();
      }
      else
      {
        fullyQualifiedClassName = dClass.name();
      }

      objyClass = ObjySchema.getObjyClass(fullyQualifiedClassName);

      // if (dClass.has_base_class(ObjyBase.CLASS_NAME))
      // {
      // if (TRACER_DEBUG.isEnabled())
      // {
      // TRACER_DEBUG.format("...classObject type: {0} - oid: {1}", classObject.type_of().name(), classObject
      // .objectID().getStoreString());
      // }
      // getBaseRelationship(classObject);
      // if (!baseRel.exists())
      // {
      // // we are the base...
      // getRevisionsRelationship(classObject);
      // getLastRevisionRelationship(classObject);
      // }
      // else
      // {
      // baseClassObject = baseRel.get_class_obj();
      // // TODO - we might want to delay getting the list of versions unless we need them.
      // // revisionsRel = baseClassObject.get_relationship(objyClass.resolve_position(ObjyBase.ATT_REVISIONS));
      // // lastRevisionRel = baseClassObject.get_relationship(objyClass.resolve_position(ObjyBase.ATT_LAST_REVISION));
      // }
      // }
      setObjectId(classObject.objectID());
      // version = classObject.get_numeric(objyClass.resolve_position(ObjyBase.ATT_VERSION)).intValue();
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }

    // count++;
    // tDiff += System.currentTimeMillis() - tStart;
  }

  private Relationship_Object getLastRevisionRelationship()
  {
    if (lastRevisionRel == null)
    {
      lastRevisionRel = classObject.nget_relationship(ObjyBase.ATT_LAST_REVISION);
    }
    return lastRevisionRel;
  }

  private Relationship_Object getRevisionsRelationship()
  {
    if (revisionsRel == null)
    {
      // revisionsRel = classObject.get_relationship(objyClass.resolve_position(ObjyBase.ATT_REVISIONS));
      revisionsRel = classObject.nget_relationship(ObjyBase.ATT_REVISIONS);
    }
    return revisionsRel;
  }

  private Relationship_Object getBaseRelationship()
  {
    if (baseRel == null)
    {
      // baseRel = classObject.get_relationship(objyClass.resolve_position(ObjyBase.ATT_BASE));
      baseRel = classObject.nget_relationship(ObjyBase.ATT_BASE);
    }
    return baseRel;
  }

  public ObjyClass objyClass()
  {
    return objyClass;
  }

  public Class_Object ooClassObject()
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }
    return classObject;
  }

  public void setObjectId(ooId objectId)
  {
    this.objectId = objectId;
  }

  /**
   *
   */
  public ooId ooId()
  {
    return objectId;
  }

  public void setEContainer(Object containerID)
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }

    // Class_Position position = objyClass.resolve_position(ObjyBase.ATT_CONTAINERID);

    SingleReferenceMapper.INSTANCE.setValue(this, ObjyBase.ATT_CONTAINERID/* position */, containerID);
  }

  public Object getEContainer()
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }

    // Class_Position position = objyClass.resolve_position(ObjyBase.ATT_CONTAINERID);
    Object value = SingleReferenceMapper.INSTANCE.getValue(this, ObjyBase.ATT_CONTAINERID/* position */);

    return value;
  }

  public ooId getEContainerAsOid()
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }

    // Class_Position position = objyClass.resolve_position(ObjyBase.ATT_CONTAINERID);
    ooId childOid = get_ooId(ObjyBase.ATT_CONTAINERID/* position */);
    return childOid;
  }

  public void setEResource(Object resourceID)
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }

    // Class_Position position = objyClass.resolve_position(ObjyBase.ATT_RESOURCEID);
    SingleReferenceMapper.INSTANCE.setValue(this, ObjyBase.ATT_RESOURCEID/* position */, resourceID);

  }

  public Object getEResource()
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }

    // Class_Position position = objyClass.resolve_position(ObjyBase.ATT_RESOURCEID);
    Object value = SingleReferenceMapper.INSTANCE.getValue(this, ObjyBase.ATT_RESOURCEID/* position */);

    return value;
  }

  public ooId getEResourceAsOid()
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }
    // Class_Position position = objyClass.resolve_position(ObjyBase.ATT_RESOURCEID);
    ooId childOid = get_ooId(ObjyBase.ATT_RESOURCEID/* position */);
    return childOid;
  }

  public void setEContainingFeature(int contFeature)
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }
    // Class_Position position = objyClass.resolve_position(ObjyBase.ATT_CONTAINER_FEATUERID);
    set_numeric(ObjyBase.ATT_CONTAINER_FEATUERID/* position */, new Numeric_Value(contFeature));
  }

  public int getEContainingFeature()
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }
    // Class_Position position = objyClass.resolve_position(ObjyBase.ATT_CONTAINER_FEATUERID);
    return get_numeric(ObjyBase.ATT_CONTAINER_FEATUERID/* position */).intValue();
  }

  /**
   * This is used to cache the composite features, (manyAttributes, manyReference, and featureMap. TBD - verify the need
   * of this.
   */
  // public Object getFeatureList(Class_Position position)
  // {
  // return featureMap.get(position);
  // }
  public Object getFeatureList(String featureName)
  {
    return featureMap.get(featureName);
  }

  // public void setFeatureList(Class_Position position, Object object)
  // {
  // featureMap.put(position, object);
  // }
  public void setFeatureList(String featureName, Object object)
  {
    featureMap.put(featureName, object);
  }

  public int getVersion()
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }
    // if (version == Integer.MAX_VALUE)
    {
      version = classObject.nget_numeric(ObjyBase.ATT_VERSION).intValue();
    }
    return version;
  }

  public void setVersion(int version)
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }
    classObject.nset_numeric(ObjyBase.ATT_VERSION, new Numeric_Value(version));
    // getVersion(); // TBD, verify the need for this call!!!!
    this.version = version;
  }

  public long getCreationTime()
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }
    long creationTime = classObject.nget_numeric(ObjyBase.ATT_CREATION_TIME).longValue();
    return creationTime;
  }

  public void setCreationTime(long creationTime)
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }
    classObject.nset_numeric(ObjyBase.ATT_CREATION_TIME, new Numeric_Value(creationTime));
  }

  public long getRevisedTime()
  {
    long revisedTime = 0;

    try
    {
      if (TRACER_DEBUG.isEnabled())
      {
        checkSession();
      }
      revisedTime = classObject.nget_numeric(ObjyBase.ATT_REVISED_TIME).longValue();
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }

    return revisedTime;
  }

  public void setRevisedTime(long revisedTime)
  {
    try
    {
      if (TRACER_DEBUG.isEnabled())
      {
        checkSession();
      }
      classObject.nset_numeric(ObjyBase.ATT_REVISED_TIME, new Numeric_Value(revisedTime));
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }
  }

  public void setBranchId(int branchId)
  {
    try
    {
      if (TRACER_DEBUG.isEnabled())
      {
        checkSession();
      }
      classObject.nset_numeric(ObjyBase.ATT_BRANCHID, new Numeric_Value(branchId));
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }

  }

  public long getBranchId()
  {
    int branchId = 0;
    try
    {
      if (TRACER_DEBUG.isEnabled())
      {
        checkSession();
      }
      branchId = classObject.nget_numeric(ObjyBase.ATT_BRANCHID).intValue();
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }
    return branchId;
  }

  public ObjyObject copy(EClass eClass, ObjyObjectManager objyObjectManager)
  {
    ObjyObject newObjyObject = null;
    ooObj obj = ooObj.create_ooObj(objectId);
    ooObj newObj = (ooObj)obj.copy(obj); // Objy internal copy.
    // Dependent structures, for example array of refs are not copies, so we
    // have to iterate and copy (deep copy).
    // newObjyObject = new ObjyObject(Class_Object.class_object_from_oid(newObj.getOid()));
    newObjyObject = objyObjectManager.getObject(newObj.getOid());

    try
    {
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.trace("ObjyObject.copy() - oid:" + ooId().getStoreString() + " version:" + getVersion());
      }
      for (EStructuralFeature feature : eClass.getEAllStructuralFeatures())
      {
        if (!(feature instanceof EAttribute || feature instanceof EReference) || !isPersistent(feature))
        {
          continue;
        }

        if (feature.isMany())
        {
          // copy this feature to the new object.
          // copy this feature to the new object.
          // get the attribute using feature name.
          d_Attribute attribute = objyClass.resolve_attribute(feature.getName());
          // System.out.println("... checking feature: " + feature.getName() + - attributeType: "
          // + attribute.type_of().name());
          if (attribute != null && attribute.type_of() instanceof d_Ref_Type)
          {
            // IS:temptest Class_Position position = objyClass.resolve_position(feature.getName());
            // ooId refOoId = get_ooId(position);
            Class_Object cObj = get_class_obj(feature.getName());
            if (cObj != null)
            {
              // System.out.println("\t\t referenced Class_Object with OID: " +cObj.objectID().getStoreString());
              d_Class refClass = cObj.type_of();
              String refClassName = refClass.name();
              if (refClassName.equals(ObjyFeatureMapArrayList.ClassName))
              {
                // we'll need to copy this one.
                TRACER_DEBUG.trace("\t TBD - copying ObjyFeatureMapArrayList attr: " + attribute.name());
              }
              else if (refClassName.equals(ObjyArrayListString.ClassName))
              {
                // we'll need to copy this one.
                TRACER_DEBUG.trace("\t TBD - copying ObjyArrayListString attr: " + attribute.name());
              }
              else if (refClassName.equals(ObjyArrayListId.className))
              {
                // we'll need to copy this one.
                // System.out.println("\t copying ObjyArrayListId attr: " + attibute.name());
                ObjyArrayListId arrayListId = new ObjyArrayListId(cObj);
                ooObj newArrayListId = arrayListId.copy(newObj);
                newObjyObject.set_ooId(feature.getName(), newArrayListId.getOid());
              }
              else if (refClassName.equals(ObjyProxy.className))
              {
                // we'll need to copy this one.
                TRACER_DEBUG.trace("\t TBD - copying ObjyProxy attr: " + attribute.name());
              }
            }
          }

        }
      }
    }
    catch (com.objy.as.asException ex)
    {
      ex.printStackTrace();
    }

    return newObjyObject;
  }

  /**
   * Use the revision info to update the object in the store.
   *
   * @param storeAccessor
   * @param revision
   */
  public void update(ObjectivityStoreAccessor storeAccessor, InternalCDORevision revision)
  {
    updateCount++;

    try
    {

      if (TRACER_DEBUG.isEnabled())
      {
        checkSession();
        TRACER_DEBUG.trace("ObjyObject.update() - oid:" + ooId().getStoreString() + " - version:" + revision.getVersion());
      }

      // this is done in the updateDate()
      // setEContainer(revision.getContainerID());
      // setEResource(revision.getResourceID());
      // setEContainingFeature(revision.getContainingFeatureID());

      updateData(storeAccessor, revision);
    }
    catch (com.objy.as.asException ex)
    {
      ex.printStackTrace();
    }
  }

  /**
   * Use the revision info to update the object in the store.
   *
   * @param storeAccessor
   * @param revision
   */
  private void updateData(ObjectivityStoreAccessor storeAccessor, InternalCDORevision revision)
  {
    EClass eClass = revision.getEClass();

    try
    {
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.trace("=> ObjyObject.updateData() - oid:" + ooId().getStoreString() + //$NON-NLS-1$
            " - version:" + revision.getVersion()); //$NON-NLS-1$
      }

      setVersion(revision.getVersion());

      setEContainer(revision.getContainerID());
      setEResource(revision.getResourceID());
      setEContainingFeature(revision.getContainingFeatureID());
      setCreationTime(revision.getTimeStamp());
      setRevisedTime(revision.getRevised());
      setBranchId(revision.getBranch().getID());

      for (EStructuralFeature feature : eClass.getEAllStructuralFeatures())
      {
        if (!(feature instanceof EAttribute || feature instanceof EReference) || !isPersistent(feature))
        {
          continue;
        }

        ITypeMapper mapper = ObjyMapper.INSTANCE.getTypeMapper(feature);
        if (mapper == null)
        {
          if (TRACER_DEBUG.isEnabled())
          {
            TRACER_DEBUG.trace("In " + ooId().getStoreString() + " - Can't find mapper for feature " + feature.getName());
          }
          continue;
        }
        // -----------------------------------------------
        // TODO - this code definitely need refactoring!!!
        // -----------------------------------------------

        // Class_Position attr = objyClass.resolve_position(feature.getName());
        if (feature.isMany())
        {
          // Object newValue = revision.getValue(feature);
          // --- TEMP solution to fix one of the tests...
          CDOList list = revision.getList(feature);
          Object[] values = new Object[list.size()];
          // we need to pass a list of ooId objects.
          // TODO - This need some work!!!!
          for (int i = 0; i < values.length; i++)
          {
            // TODO - this code need refactoring...
            Object value = list.get(i);
            if (null == value)
            {
              values[i] = value;
              continue;
            }
            else if (value instanceof CDOIDExternal)
            {
              TRACER_DEBUG.trace("... CDOIDExternal inserted, at:" + i + ", content:" + ((CDOIDExternal)value).getURI());
              // System.out.println("value is a proxy object - it should be handled by the mapper.");
              // create an ObjyProxy object to hold the the value.
              ObjyProxy proxyObject = ObjyProxy.createObject(ooId());
              proxyObject.setUri(((CDOIDExternal)value).getURI());
              values[i] = proxyObject.ooId();

            }
            else if (value instanceof CDOID)
            {
              values[i] = OBJYCDOIDUtil.getooId((CDOID)value);
            }
            else if (value instanceof FeatureMap.Entry)
            {
              FeatureMap.Entry entry = (FeatureMap.Entry)value;
              EStructuralFeature entryFeature = entry.getEStructuralFeature();
              Object entryValue = entry.getValue();

              ooId oid = null;
              if (entryValue instanceof CDOIDExternal)
              {
                TRACER_DEBUG.trace("... CDOIDExternal inserted, at:" + i + ", content:" + ((CDOIDExternal)entryValue).getURI());
                // System.out.println("value is a proxy object - it should be handled by the mapper.");
                // create an ObjyProxy object to hold the the value.
                ObjyProxy proxyObject = ObjyProxy.createObject(ooId());
                proxyObject.setUri(((CDOIDExternal)entryValue).getURI());
                oid = proxyObject.ooId();
              }
              else if (entryValue instanceof CDOID)
              {
                oid = OBJYCDOIDUtil.getooId((CDOID)entryValue);
              }
              else
              {
                if (TRACER_DEBUG.isEnabled())
                {
                  TRACER_DEBUG.trace("OBJY: don't know what kind of entryValue is this!!! - " + entryValue);
                }
              }
              // FeatureMapEntry is a presistent class.
              ObjyFeatureMapEntry featureMapEntry = new ObjyFeatureMapEntry(entryFeature.getFeatureID(), oid, objectId);

              // this.cluster(featureMapEntry);
              values[i] = featureMapEntry;
            }
            else if (value.equals(InternalCDOList.UNINITIALIZED))
            {
              TRACER_DEBUG.format("...GOT UNINITIALIZED at {0}, listSize:{1}, feature:{2}, oid:{3}", i, values.length, feature.getName(),
                  objectId.getStoreString());
              continue;
            }
            else
            {
              // different feature then.
              values[i] = value;
            }
          }

          ((IManyTypeMapper)mapper).setAll(this, feature, 0, values);
        }
        else
        {
          Object newValue = revision.get(feature, feature.getFeatureID());
          // if (newValue instanceof CDOIDExternal)
          // {
          // System.out.println("value is a proxy object");
          // }
          ((ISingleTypeMapper)mapper).setValue(this, feature, newValue);
        }
      }
    }
    catch (com.objy.as.asException ex)
    {
      ex.printStackTrace();
    }
  }

  public ObjyObject getLastRevision(ObjyObjectManager objyObjectManager)
  {
    if (!getLastRevisionRelationship().exists())
    {
      return this;
    }

    // Class_Object lastRevision = lastRevisionRel.get_class_obj();
    ooId lastRevisionOid = getLastRevisionRelationship().get_ooId();
    // return new ObjyObject(lastRevision);
    return objyObjectManager.getObject(lastRevisionOid);
  }

  public ObjyObject getRevisionByVersion(int version, long branchId, ObjyObjectManager objyObjectManager)
  {
    ObjyObject objyRevision = null;
    int objectVersion = getVersion();
    long objectBranchId = getBranchId();

    if (branchId == objectBranchId && Math.abs(objectVersion) == version)
    {
      // there is a first time for everything...
      return this;
    }

    // check last revision first.
    objyRevision = getLastRevision(objyObjectManager);
    objectVersion = objyRevision.getVersion();
    objectBranchId = objyRevision.getBranchId();
    if (branchId == objectBranchId && Math.abs(objectVersion) == version)
    {
      return objyRevision;
    }

    // Session.getCurrent().setReturn_Class_Object(true);
    // int numRevisions = (int) revisions.size();

    @SuppressWarnings("unchecked")
    Iterator<ooObj> itr = getRevisionsRelationship().get_iterator();
    while (itr.hasNext())
    {
      // objyRevision = new ObjyObject(itr.next());
      objyRevision = objyObjectManager.getObject(itr.next().getOid());
      objectVersion = objyRevision.getVersion();
      objectBranchId = objyRevision.getBranchId();
      if (branchId == objectBranchId && Math.abs(objectVersion) == version)
      {
        return objyRevision;
      }
      objyRevision = null;
    }

    return null;
  }

  public void addToRevisions(ObjyObject objyRevision)
  {
    try
    {
      getRevisionsRelationship().add(objyRevision.objectId);
      // set it as last rev.
      getLastRevisionRelationship().clear(); // Ouch!! performance issue...
      getLastRevisionRelationship().form(objyRevision.objectId);
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }
  }

  // /**
  // * Wrapper around ObjyObject to allow clustering of other objects near this one.
  // */
  // private void cluster(ooObj otherObj)
  // {
  // try
  // {
  // ooObj thisObj = ooObj.create_ooObj(objectId);
  // thisObj.cluster(otherObj);
  // }
  // catch (ObjyRuntimeException ex)
  // {
  // ex.printStackTrace();
  // }
  // }

  /**
   * Fetch data from the store and return a revision.
   */
  public boolean fetch(ObjectivityStoreAccessor storeAccessor, InternalCDORevision revision, int listChunk)
  {
    boolean bRet = true;
    fetchCount++;
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }
    EClass eClass = revision.getEClass();

    try
    {
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.trace("ObjyObject.fetch() - oid:" + ooId().getStoreString() + " version:" + getVersion());
      }
      // Put the version of the objects;
      revision.setVersion(getVersion());
      revision.setContainerID(getEContainer());
      revision.setResourceID((CDOID)getEResource());
      revision.setContainingFeatureID(getEContainingFeature());
      long creationTime = getCreationTime();
      long revisedTime = getRevisedTime();

      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.trace("... ObjyObject.creationTime: " + creationTime);
        TRACER_DEBUG.trace("... ObjyObject.revisedTime : " + revisedTime);
      }

      revision.setRevised(revisedTime);

      for (EStructuralFeature feature : eClass.getEAllStructuralFeatures())
      {
        if (!(feature instanceof EAttribute || feature instanceof EReference) || !isPersistent(feature))
        {
          continue;
        }

        if (feature.isMany())
        {
          int featureSize = size(feature);
          int chunkSize = featureSize;
          if (listChunk != CDORevision.UNCHUNKED && listChunk > 0)
          {
            chunkSize = Math.min(chunkSize, listChunk);
          }

          Object[] objects = getAll(feature, 0, chunkSize);
          // if (size > 0)
          {
            // TODO - we could use getList() then fill the array with values, we
            // also
            // need to consider the chunking...
            // InternalCDOList cdoList =
            // (InternalCDOList)CDOListFactory.DEFAULT.createList(objects.length,
            // objects.length, 0);
            // TODO - use the following line instead of creating the cdoList
            // above.
            MoveableList<Object> list = revision.getList(feature);

            // size = Math.min(size, 0);
            for (int i = 0; i < chunkSize; i++)
            {
              if (objects[i] instanceof ooId)
              {
                // TODO - this code need refactoring....
                CDOID cdoId = null;
                ooId objyOid = (ooId)objects[i];
                if (objyOid.isNull())
                {
                  cdoId = OBJYCDOIDUtil.getCDOID(objyOid);
                }
                else
                {
                  Class_Object refClassObject = Class_Object.class_object_from_oid((ooId)objects[i]);

                  if (refClassObject.type_of().name().equals(ObjyProxy.className))
                  {
                    // System.out.println("OBJY: Got proxy: " + refClassObject.objectID().getStoreString());
                    ObjyProxy proxyObject = new ObjyProxy(refClassObject);
                    // cdoList.set(i,
                    // OBJYCDOIDUtil.createCDIDExternal(proxyObject));
                    cdoId = OBJYCDOIDUtil.createCDIDExternal(proxyObject);
                  }
                  else
                  {
                    cdoId = OBJYCDOIDUtil.getCDOID(objyOid);
                  }
                  refClassObject = null;
                }
                list.add(cdoId);

                continue;
              }
              else if (objects[i] instanceof ObjyFeatureMapEntry)
              {
                FeatureMap.Entry entry = getFeatureMapEntry(eClass, (ObjyFeatureMapEntry)objects[i]);
                list.add(entry);
              }
              else
              {
                // different feature then.
                // System.out.println("-->> Hmmm fetch() feature (" + i + ") -> feature:" + feature.getName()
                // + " - value:" + objects[i]);
                // cdoList.set(i, objects[i]);
                list.add(objects[i]);
              }
            }
            // fill the rest if needed.
            if (featureSize - chunkSize > 0)
            {
              for (int i = 0; i < featureSize - chunkSize; i++)
              {
                list.add(InternalCDOList.UNINITIALIZED);
              }
            }
          }
        }
        else
        {
          Object object = get(feature, 0);

          /**
           * TODO - verify if this is needed for 2.x if (cdoFeature.getType() == CDOType.CUSTOM) { object =
           * EcoreUtil.convertToString((EDataType)eFeature.getEType(), object); }
           */
          revision.set(feature, 0, object);
        }
      }
    }
    catch (com.objy.as.asException ex)
    {
      ex.printStackTrace();
    }

    return bRet;
  }

  /**
   * Fetch data for a specific feature from the store, and return a list of objects. Used by
   * ObjectivityStoreChunkAccessor
   */
  public List<Object> fetchList(ObjectivityStoreAccessor storeAccessor, EStructuralFeature feature, int startIndex, int chunkSize)
  {
    fetchCount++;

    List<Object> results = new ArrayList<Object>();
    EClass eClass = feature.getEContainingClass();

    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }

    try
    {
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.trace("ObjyObject.fetch() - feature:" + feature.getName() + "from Object: " + ooId().getStoreString() + " version:" + getVersion());
      }
      int featureSize = size(feature);
      chunkSize = Math.min(featureSize - startIndex, chunkSize);

      Object[] objects = getAll(feature, startIndex, chunkSize);
      convertToCdoList(objects, results, eClass, chunkSize);
    }
    catch (com.objy.as.asException ex)
    {
      ex.printStackTrace();
    }

    return results;
  }

  /**
   * Function thats takes a list of Objy objects and convert them to CDO IDs This function is used by queryXRefs() as
   * well.
   */
  protected void convertToCdoList(Object[] objects, List<Object> results, EClass eClass, int chunkSize)
  {
    {
      for (int i = 0; i < chunkSize; i++)
      {
        if (objects[i] instanceof ooId)
        {
          // TODO - this code need refactoring....

          // System.out.println("-->> IS: getting Class_Object from OID: "
          // + childObject.getStoreString());
          CDOID cdoId = null;
          ooId objyOid = (ooId)objects[i];
          if (objyOid.isNull())
          {
            cdoId = OBJYCDOIDUtil.getCDOID(objyOid);
          }
          else
          {
            Class_Object refClassObject = Class_Object.class_object_from_oid(objyOid);

            if (refClassObject.type_of().name().equals(ObjyProxy.className))
            {
              ObjyProxy proxyObject = new ObjyProxy(refClassObject);
              cdoId = OBJYCDOIDUtil.createCDIDExternal(proxyObject);
            }
            else
            {
              cdoId = OBJYCDOIDUtil.getCDOID(objyOid);
            }
            refClassObject = null;
          }

          results.add(cdoId);
          continue;

        }
        else if (objects[i] instanceof ObjyFeatureMapEntry)
        {
          FeatureMap.Entry entry = getFeatureMapEntry(eClass, (ObjyFeatureMapEntry)objects[i]);
          results.add(entry);
        }
      }
    }
  }

  private FeatureMap.Entry getFeatureMapEntry(EClass eClass, ObjyFeatureMapEntry mapEntry)
  {
    ooId oid = mapEntry.getObject();
    CDOID id = null;
    Class_Object refClassObject = Class_Object.class_object_from_oid(oid);
    if (refClassObject.type_of().name().equals(ObjyProxy.className))
    {
      ObjyProxy proxyObject = new ObjyProxy(refClassObject);
      id = OBJYCDOIDUtil.createCDIDExternal(proxyObject);
    }
    else
    {
      id = OBJYCDOIDUtil.getCDOID(oid);
    }

    EStructuralFeature entryFeature = eClass.getEStructuralFeature(mapEntry.getTagId());
    FeatureMap.Entry entry = CDORevisionUtil.createFeatureMapEntry(entryFeature, id);
    return entry;
  }

  /**
   * Get the size of the composite object using the store info.
   *
   * @param feature
   * @return
   */
  private int size(EStructuralFeature feature)
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }
    int size = 0;

    // Class_Position position = objyClass().resolve_position(feature.getName());
    try
    {
      IManyTypeMapper mapper = (IManyTypeMapper)ObjyMapper.INSTANCE.getTypeMapper(feature);

      size = mapper.size(this, feature);

      if (TRACER_DEBUG.isEnabled())
      {
        // TODO - verify the message.
        TRACER_DEBUG.trace("Size of object " + ooId().getStoreString() + " - is: " + size + " - feature: " + feature.getName());
      }
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }
    return size;
  }

  /**
   * Get the value of an attribute from the persistent object.
   */
  public Object get(EStructuralFeature feature)
  {
    if (feature.isMany())
    {
      return getAll(feature, 0, CDORevision.UNCHUNKED);
    }
    return get(feature, 0);
  }

  /**
   * Get the value of an attribute at index (if many) from the persistent object.
   *
   * @param feature
   * @param index
   * @return
   */
  private Object get(EStructuralFeature feature, int index)
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
    }

    if (TRACER_DEBUG.isEnabled())
    {
      // TODO - verify the message.
      TRACER_DEBUG.trace("Getting object " + objectId.getStoreString() + " <feature ' " + feature.getName() + "':" + feature.getEType() + "> from " + this);
    }

    // Class_Position position =
    // this.objyClass().resolve_position(feature.getName());

    ITypeMapper mapper = ObjyMapper.INSTANCE.getTypeMapper(feature);
    Object value = null;
    try
    {
      if (feature.isMany())
      {
        value = ((IManyTypeMapper)mapper).getValue(this, feature, index);
      }
      else
      {
        value = ((ISingleTypeMapper)mapper).getValue(this, feature);
      }
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }
    return value;
  }

  /**
   * Get all the values of an attribute, used for feature.isMany(). This function is also used by the
   * ObjectivityStoreChunkReader to read chunks of data from a feature.
   *
   * @param feature
   * @param size
   * @return
   */
  protected Object[] getAll(EStructuralFeature feature, int startIndex, int chunkSize)
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
      // TODO - verify the message.
      TRACER_DEBUG.trace("Get All objects for ID: " + ooId().getStoreString() + " <feature ' " + feature/*
                                                                                                         * .getName( )
                                                                                                         */
          + "':" + feature.getEType() + "> from " + this);
    }

    assert feature.isMany();
    Object[] values = null;

    try
    {
      IManyTypeMapper mapper = (IManyTypeMapper)ObjyMapper.INSTANCE.getTypeMapper(feature);
      values = mapper.getAll(this, feature, startIndex, chunkSize);
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }

    return values;
  }

  public void add(EStructuralFeature feature, int index, Object value)
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
      TRACER_DEBUG.trace("Adding object " + value + " to " + ooId().getStoreString());
    }

    assert feature.isMany();

    try
    {
      IManyTypeMapper mapper = (IManyTypeMapper)ObjyMapper.INSTANCE.getTypeMapper(feature);

      // -- TODO -- verify the need to this one.
      // ensureObjectAttached(feature, value);

      // I believe we do the conversion in the add()
      // value = provider.convertToStore(ooObject, value);

      mapper.add(this, feature, index, value);
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }
  }

  /***
   * @param feature
   */
  public void clear(EStructuralFeature feature)
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
      TRACER_DEBUG.trace("Clear List for " + ooId().getStoreString());
    }

    // Class_Position position = objyClass.resolve_position(feature.getName());
    try
    {
      ITypeMapper mapper = ObjyMapper.INSTANCE.getTypeMapper(feature);

      ((IManyTypeMapper)mapper).clear(this, feature);
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }
  }

  public void move(EStructuralFeature feature, int targetIndex, int sourceIndex)
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
      TRACER_DEBUG.trace("Move element from " + sourceIndex + " to " + targetIndex);
    }
    try
    {
      ITypeMapper mapper = ObjyMapper.INSTANCE.getTypeMapper(feature);

      ((IManyTypeMapper)mapper).move(this, feature, targetIndex, sourceIndex);
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }
  }

  public Object remove(EStructuralFeature feature, int index)
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
      TRACER_DEBUG.trace("Remove object from '" + ooId().getStoreString() + "' at index " + index);
    }

    // Class_Position position = objyClass.resolve_position(feature.getName());
    Object retObject = null;

    try
    {
      IManyTypeMapper mapper = (IManyTypeMapper)ObjyMapper.INSTANCE.getTypeMapper(feature);

      Object value = mapper.remove(this, feature, index);

      if (feature instanceof EAttribute)
      {
        return value;
      }

      retObject = OBJYCDOIDUtil.getCDOID((ooId)value);
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }

    return retObject;

  }

  public Object set(EStructuralFeature feature, int index, Object value)
  {
    if (TRACER_DEBUG.isEnabled())
    {
      checkSession();
      TRACER_DEBUG.trace("Set object '" + ooId().getStoreString() + "' feature : " + feature.getName());
    }

    /*
     * int i =0; for (EClass superEClass : object.eClass().getESuperTypes()) { if
     * (feature.getEContainingClass().isSuperTypeOf(superEClass)) { break; } i++; break; } String className = null; if
     * (i == 0) { className = EProposedManager.getObjectivityClass(feature.getEContainingClass()); } else { className =
     * EProposedManager.getObjectivityClass(feature.getEContainingClass(), true); } Class_Position position =
     * ooObject.ooClass().resolve_position(className + "::" + feature.getName());
     */
    // Class_Position position = objyClass.resolve_position(feature.getName());
    try
    {
      ITypeMapper mapper = ObjyMapper.INSTANCE.getTypeMapper(feature);

      // --- TODO --- verify the need...
      // ensureObjectAttached(this, feature, value);

      /***
       * I believe we do the conversion in the setValue if (feature instanceof EReference) { value =
       * CDOIDUtil.getooId((CDOID)value); }
       ***/

      if (feature.isMany())
      {
        ((IManyTypeMapper)mapper).setValue(this, feature, index, value);
      }
      else
      {
        ((ISingleTypeMapper)mapper).setValue(this, feature, value);
      }
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }

    return value;
  }

  /***
   * @param feature
   */
  public void unset(EStructuralFeature feature)
  {
    set(feature, 0, null);
  }

  protected void checkSession()
  {
    // 100610 - IS: disabled for now, since we have an issue with oojava_epl.jar "getSession()"
    // is not available.
    // if (TRACER_DEBUG.isEnabled())
    // {
    // try
    // {
    // if (!classObject.getPersistor().getSession().isOpen())
    // {
    // throw new Exception("Attempt to work on an object " + objectId.toString() + " without a trx. [Session: "
    // + classObject.getPersistor().getSession() + "]");
    // }
    // }
    // catch (Exception ex)
    // {
    // ex.printStackTrace();
    // } // for debugging.
    // }
  }

  /***
   * Iterate over the attributes and references and mark them deleted. This will only be called in non-audit mode.
   */
  public void delete(ObjectivityStoreAccessor storeAccessor, ObjyObjectManager objectManager)
  {
    EClass eClass = ObjySchema.getEClass(storeAccessor.getStore(), objyClass());
    try
    {
      for (EStructuralFeature feature : eClass.getEAllStructuralFeatures())
      {
        if (!(feature instanceof EAttribute || feature instanceof EReference) || !isPersistent(feature))
        {
          continue;
        }

        if (feature.isMany())
        {
          deleteFeatureObjects(objectManager, feature);
        }
        else
        {
          ITypeMapper mapper = ObjyMapper.INSTANCE.getTypeMapper(feature);

          if (mapper == null)
          {
            continue;
          }
          mapper.delete(this, feature);
        }
      }
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }
  }

  private void deleteFeatureObjects(ObjyObjectManager objectManager, EStructuralFeature feature)
  {
    // TODO - verify that we can do this to all referenced list.
    // I'm not sure if it's valid when you have many-many relationship.
    Object[] objects = getAll(feature, 0, CDORevision.UNCHUNKED);

    if (objects == null)
    {
      return;
    }

    for (int i = 0; i < objects.length; i++)
    {
      if (objects[i] instanceof ooId)
      {
        ooId oid = (ooId)objects[i];
        // TODO - this code need refactoring....
        ooObj obj = ooObj.create_ooObj(oid);
        if (obj.isDead())
        {
          continue;
        }

        Class_Object refClassObject = Class_Object.class_object_from_oid(oid);

        if (refClassObject.type_of().name().equals(ObjyProxy.className))
        {
          obj.delete();
        }
        else
        {
          // if this object is a parent (resourceId or
          // containerId) for obj, then we
          // need to mark obj version as (-1).
          ObjyObject childObjyObject = objectManager.getObject(oid);
          ooId containerId = childObjyObject.getEContainerAsOid();
          ooId resourceId = childObjyObject.getEResourceAsOid();
          int childVersion = childObjyObject.getVersion();
          if (containerId.equals(objectId) || resourceId.equals(objectId))
          {
            childObjyObject.setVersion(-childVersion);
          }

        }
      }
      else if (objects[i] instanceof ObjyFeatureMapEntry)
      {
        ObjyFeatureMapEntry mapEntry = (ObjyFeatureMapEntry)objects[i];
        ooId oid = mapEntry.getObject();
        ooObj obj = ooObj.create_ooObj(oid);
        obj.delete();
      }
      else
      {
        // different feature then.
        if (TRACER_DEBUG.isEnabled())
        {
          TRACER_DEBUG
              .trace("-->> No process to delete() feature (" + i + ") -> feature:" + feature.getName() + " - value:" + objects[i] + " ... nothing to do here.");
        }
      }
    }
  }

  // Wrapper functions over class object.
  // public Numeric_Value get_numeric(Class_Position position)
  // {
  // return classObject.get_numeric(position);
  // }
  public Numeric_Value get_numeric(String attributeName)
  {
    return classObject.nget_numeric(attributeName);
  }

  // public String_Value get_string(Class_Position position)
  // {
  // return classObject.get_string(position);
  // }
  public String_Value get_string(String attributeName)
  {
    return classObject.nget_string(attributeName);
  }

  // public void set_numeric(Class_Position position, Numeric_Value value)
  // {
  // classObject.set_numeric(position, value);
  // }
  public void set_numeric(String attributeName, Numeric_Value value)
  {
    classObject.nset_numeric(attributeName, value);
  }

  // public VArray_Object get_varray(Class_Position position)
  // {
  // return classObject.get_varray(position);
  // }
  public VArray_Object get_varray(String attributeName)
  {
    return classObject.nget_varray(attributeName);
  }

  // public ooId get_ooId(Class_Position position)
  // {
  // return classObject.get_ooId(position);
  // }
  public ooId get_ooId(String attributeName)
  {
    return classObject.nget_ooId(attributeName);
  }

  // public Class_Object get_class_obj(Class_Position position)
  // {
  // return classObject.get_class_obj(position);
  // }

  public Class_Object get_class_obj(String attributeName)
  {
    return classObject.nget_class_obj(attributeName);
  }

  // public void set_ooId(Class_Position position, ooId object)
  // {
  // classObject.set_ooId(position, object);
  // }

  public void set_ooId(String attributeName, ooId object)
  {
    classObject.nset_ooId(attributeName, object);
  }

  /**
   * Return the CDOID for the ObjyObject, it will go up to the base revision, and return it's ID.
   */
  public CDOID getRevisionId()
  {
    if (revisionId == null)
    {
      if (hasBaseRelationship())
      {
        baseClassObject = getBaseRelationship().get_class_obj();
        revisionId = baseClassObject.objectID();
      }
      else
      {
        revisionId = objectId;
      }
    }

    return OBJYCDOIDUtil.getCDOID(revisionId);
  }

  public ObjyObject getBaseObject()
  {
    ObjyObject objyObject = null;
    if (hasBaseRelationship())
    {
      baseClassObject = getBaseRelationship().get_class_obj();
      objyObject = new ObjyObject(baseClassObject);
    }
    else
    {
      objyObject = this;
    }
    return objyObject;
  }

  private boolean hasBaseRelationship()
  {
    if (!hasBaseRelationshipChecked)
    {
      hasBaseRelationshipChecked = getBaseRelationship().exists();
    }
    return hasBaseRelationshipChecked;
  }

  // private boolean hasRevisionsRelationship()
  // {
  // if (!hasRevisionsRelChecked)
  // {
  // hasRevisionsRelChecked = getRevisionsRelationship().exists();
  // }
  // return hasRevisionsRelChecked;
  // }
  //
  // private boolean hasLastRevisionRelationship()
  // {
  // if (!hasLastRevisionRelChecked)
  // {
  // hasLastRevisionRelChecked = getLastRevisionRelationship().exists();
  // }
  // return hasLastRevisionRelChecked;
  // }

  /**
   * Return the revision that satisfies the timeStamp and branchId constrains.
   *
   * @param objyObjectManager
   */
  public ObjyObject getRevision(long timeStamp, int branchId, ObjyObjectManager objyObjectManager)
  {
    ObjyObject objyRevision = null;

    // // evaluate current first.
    // if (evaluateRevision(timeStamp, branchId, this))
    // {
    // return this;
    // }
    //
    // // if we don't have other revisions.
    // if (!getLastRevisionRelationship().exists())
    // {
    // return null;
    // }

    // check last revision first.
    objyRevision = getLastRevision(objyObjectManager);
    if (evaluateRevision(timeStamp, branchId, objyRevision))
    {
      return objyRevision;
    }

    ObjyObject possibleRevision = null;

    // check first revision.
    if (evaluateRevision(timeStamp, branchId, this))
    {
      possibleRevision = this;
    }

    @SuppressWarnings("unchecked")
    Iterator<ooObj> itr = getRevisionsRelationship().get_iterator();
    while (itr.hasNext())
    {
      // objyRevision = new ObjyObject(itr.next());
      objyRevision = objyObjectManager.getObject(itr.next().getOid());
      if (evaluateRevision(timeStamp, branchId, objyRevision))
      {
        possibleRevision = objyRevision;
      }
    }

    return possibleRevision;
  }

  /**
   * return true if the objyRevision satisfies the constrains. This function is only called in case of auditing, and
   * branching.
   */
  protected boolean evaluateRevision(long timeStamp, int branchId, ObjyObject objyRevision)
  {
    // check the branchId first.
    if (objyRevision.getBranchId() == branchId)
    {
      // long revisedTS = objyRevision.getRevisedTime();
      // if (timeStamp != CDOBranchPoint.UNSPECIFIED_DATE)
      // {
      // long creationTS = objyRevision.getCreationTime();
      // if (creationTS <= timeStamp && (revisedTS == CDOBranchPoint.UNSPECIFIED_DATE || revisedTS >= timeStamp))
      // // if (creationTS >= timeStamp && (revisedTS == CDOBranchPoint.UNSPECIFIED_DATE || revisedTS <= timeStamp))
      // {
      // return true;
      // }
      // }
      // else if (revisedTS == CDOBranchPoint.UNSPECIFIED_DATE) // return the latest version in that branch.
      // {
      // return true;
      // }

      long creationTS = objyRevision.getCreationTime();
      long revisedTS = objyRevision.getRevisedTime();
      if (CDOCommonUtil.isValidTimeStamp(timeStamp, creationTS, revisedTS))
      {
        return true;
      }
    }
    return false;
  }

  public void detach(int version, CDOBranch branch, long timeStamp)
  {
    ObjyClass objyClass = ObjySchema.getObjyClass(ObjyBase.CLASS_NAME);
    Class_Object detachedClassObject = Class_Object.new_persistent_object(objyClass.getASClass(), objectId, false);
    if (TRACER_DEBUG.isEnabled())
    {
      ObjyObjectManager.newInternalObjCount++;
    }
    ObjyObject detachedObjyObject = null;

    try
    {
      detachedObjyObject = new ObjyObject(detachedClassObject);

      detachedObjyObject.setVersion(-(version + 1));
      detachedObjyObject.setBranchId(branch.getID());
      detachedObjyObject.setCreationTime(timeStamp);

      // add it to the revisions.
      addToRevisions(detachedObjyObject);
    }
    catch (RuntimeException ex)
    {
      ex.printStackTrace();
    }
  }

  public static boolean isPersistent(EStructuralFeature feature)
  {
    return EMFUtil.isPersistent(feature);
  }

}