Java BasicEList.data方法代碼示例

import org.eclipse.emf.common.util.BasicEList; //導入方法依賴的package包/類
/**
 * Lifted from the removeAll method in NotifyingListImpl. (and simplified)
 * 
 * @param <T>
 * @param data
 * @param collection
 * @return
 */
public static <T> int[] getPositions(EList<T> data, List<? extends T> collection) {
	int listSize = collection.size();
	int [] positions = new int [listSize];
	int count = 0;
	BasicEList<Object> list = new BasicEList<Object>(collection);
       Object[] objects = list.data();
	for (int i = 0; i < data.size(); ++i) {
		@SuppressWarnings("unchecked") T initialObject = data.get(i);
		T object = initialObject;
		LOOP:
		for (int repeat = 0; repeat < 2; ++repeat) {
			for (int j = listSize; --j >= 0; ) {
				if (object == objects[j]) {
					if (positions.length <= count) {
						int [] oldPositions = positions;
						positions = new int [2 * positions.length];
						System.arraycopy(oldPositions, 0, positions, 0, count);
					}
					positions[count++] = i;
					break LOOP;
				}
			}
			if (object == initialObject) {
				break;
			}
		}
	}
	return positions;
}
 

import org.eclipse.emf.common.util.BasicEList; //導入方法依賴的package包/類
public void remove(EObject eObject, EReference eReference, EObject crossReferencedEObject)
{
  if (!resolve())
  {
    removeProxy(crossReferencedEObject, eObject);
  }
  BasicEList<EStructuralFeature.Setting> collection = (BasicEList<EStructuralFeature.Setting>)get(crossReferencedEObject);
  if (collection != null)
  {
    EStructuralFeature.Setting [] settingData =  (EStructuralFeature.Setting[])collection.data();
    for (int i = 0, size = collection.size(); i < size; ++i)
    {
      EStructuralFeature.Setting setting = settingData[i];
      if (setting.getEObject() == eObject && setting.getEStructuralFeature() == eReference)
      {
        if (collection.size() == 1)
        {
          super.remove(crossReferencedEObject);  
        }
        else
        {
          collection.remove(i);
        }
        break;
      }
    }
  }      
}
 

import org.eclipse.emf.common.util.BasicEList; //導入方法依賴的package包/類
public EList<EReference> getEAllContainments()
{
  if (eAllContainments == null)
  {
    BasicEList<EReference> result = 
      new UniqueEList<EReference>()
      {
        private static final long serialVersionUID = 1L;

        @Override
        protected Object [] newData(int capacity)
        {
          return new EReference [capacity];
        }

        @Override
        protected boolean useEquals()
        {
          return false;
        }
      };

    for (EReference eReference : getEAllReferences())
    {
      if (eReference.isContainment())
      {
        result.add(eReference);
      }
    }

    result.shrink();
    eAllContainments = 
      new EcoreEList.UnmodifiableEList.FastCompare<EReference>
        (this, EcorePackage.eINSTANCE.getEClass_EAllContainments(), result.size(), result.data()); 
    getESuperAdapter().setAllContainmentsCollectionModified(false);
  }

  return eAllContainments;
}
 

import org.eclipse.emf.common.util.BasicEList; //導入方法依賴的package包/類
public EList<EReference> getEAllReferences()
{
  if (eAllReferences == null)
  {
    class ReferenceList extends UniqueEList<EReference>
    {
      private static final long serialVersionUID = 1L;

      public ReferenceList()
      {
        super();
      }

      @Override
      protected Object [] newData(int capacity)
      {
        return new EReference [capacity];
      }

      @Override
      protected boolean useEquals()
      {
        return false;
      }
    }
    BasicEList<EReference> result = new ReferenceList();
    BasicEList<EReference> references = new ReferenceList();

    Set<EClass> computationInProgress = COMPUTATION_IN_PROGRESS.get();
    if (computationInProgress.add(this))
    {
      for (EClass eSuperType : getESuperTypes())
      {
        result.addAll(eSuperType.getEAllReferences());
      }
      computationInProgress.remove(this);
      if (computationInProgress.isEmpty())
      {
        COMPUTATION_IN_PROGRESS.remove();
      }
    }
    for (EStructuralFeature eStructuralFeature : getEStructuralFeatures())
    {
      if (eStructuralFeature instanceof EReference)
      {
        references.add((EReference)eStructuralFeature);
      }
    }

    references.shrink();
    eReferences = 
      new EcoreEList.UnmodifiableEList.FastCompare<EReference>
        (this, EcorePackage.eINSTANCE.getEClass_EReferences(), references.size(), references.data())
      {
        private static final long serialVersionUID = 1L;

        @SuppressWarnings("unchecked")
        @Override
        public void addUnique(EReference object)
        {
          ((InternalEList<EReference>)(InternalEList<?>)getEStructuralFeatures()).addUnique(object);
        }

        @Override
        public boolean add(EReference object)
        {
          System.err.println("Please fix your code to add using EClass.getEStructuralFeatures() instead of EClass.getEReferences()");
          return getEStructuralFeatures().add(object);
        }
      };

    result.addAll(eReferences);
    result.shrink();
    eAllReferences = 
      new EcoreEList.UnmodifiableEList.FastCompare<EReference>
        (this, EcorePackage.eINSTANCE.getEClass_EAllReferences(), result.size(), result.data());
    getESuperAdapter().setAllReferencesCollectionModified(false);
  }

  return eAllReferences;
}
 

import org.eclipse.emf.common.util.BasicEList; //導入方法依賴的package包/類
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated modifiable
 */
public EList<EOperation> getEAllOperations()
{
  if (eAllOperations == null)
  {
    BasicEList<EOperation> result = 
      new UniqueEList<EOperation>()
      {
        private static final long serialVersionUID = 1L;

        @Override
        protected Object [] newData(int capacity)
        {
          return new EOperation [capacity];
        }

        @Override
        protected boolean useEquals()
        {
          return false;
        }
      };

    Set<EClass> computationInProgress = COMPUTATION_IN_PROGRESS.get();
    if (computationInProgress.add(this))
    {
      for (EClass eSuperType : getESuperTypes())
      {
        result.addAll(eSuperType.getEAllOperations());
      }
      computationInProgress.remove(this);
      if (computationInProgress.isEmpty())
      {
        COMPUTATION_IN_PROGRESS.remove();
      }
    }
    int operationID = result.size();
    for (Iterator<EOperation> i = getEOperations().iterator(); i.hasNext(); ++operationID)
    {
      ((EOperationImpl)i.next()).setOperationID(operationID);
    }
    result.addAll(getEOperations());
    result.shrink();
    eAllOperations = 
      new EcoreEList.UnmodifiableEList.FastCompare<EOperation>
        (this, EcorePackage.eINSTANCE.getEClass_EAllOperations(), result.size(), result.data());
    eAllOperationsData = (EOperation[])result.data();
    if (eAllOperationsData == null)
    {
      eAllOperationsData = NO_EALL_OPERATIONS_DATA;
    }

    eOperationToOverrideMap = null; 

    getESuperAdapter().setAllOperationsCollectionModified(false);
  }

  return eAllOperations;
}
 

import org.eclipse.emf.common.util.BasicEList; //導入方法依賴的package包/類
/**
 * Returns all the super types in the hierarchy.
 */
public EList<EClass> getEAllSuperTypes()
{
  if (eAllSuperTypes == null)
  {
    BasicEList<EClass> result = 
      new UniqueEList<EClass>()
      {
        private static final long serialVersionUID = 1L;

        @Override
        protected Object [] newData(int capacity)
        {
          return new EClassifier [capacity];
        }

        @Override
        protected boolean useEquals()
        {
          return false;
        }
      };

    Set<EClass> computationInProgress = COMPUTATION_IN_PROGRESS.get();
    if (computationInProgress.add(this))
    {
      for (EClass eSuperType : getESuperTypes())
      {
        EList<EClass> higherSupers = eSuperType.getEAllSuperTypes();
        result.addAll(higherSupers);
        result.add(eSuperType);
      }
      computationInProgress.remove(this);
    }

    result.shrink();
    eAllSuperTypes = 
      new EcoreEList.UnmodifiableEList.FastCompare<EClass>
        (this, EcorePackage.eINSTANCE.getEClass_EAllSuperTypes(), result.size(), result.data());
    getESuperAdapter().setAllSuperCollectionModified(false);
  }

  return eAllSuperTypes;
}