Java BasicEList.shrink方法代码示例

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;
}