com.intellij.util.ArrayFactory Java Examples

/**
 * @return children of specified type, taken from stubs (if this element is currently stub-based) or AST (otherwise).
 */
@Nonnull
public <S extends StubElement, Psi extends PsiElement> Psi[] getStubOrPsiChildren(@Nonnull IStubElementType<S, ? extends Psi> elementType, @Nonnull ArrayFactory<? extends Psi> f) {
  T stub = getGreenStub();
  if (stub != null) {
    //noinspection unchecked
    return (Psi[])stub.getChildrenByType(elementType, f);
  }
  else {
    final ASTNode[] nodes = SharedImplUtil.getChildrenOfType(getNode(), elementType);
    Psi[] psiElements = f.create(nodes.length);
    for (int i = 0; i < nodes.length; i++) {
      //noinspection unchecked
      psiElements[i] = (Psi)nodes[i].getPsi();
    }
    return psiElements;
  }
}
 

/**
 * @return children of specified type, taken from stubs (if this element is currently stub-based) or AST (otherwise).
 */
@Nonnull
public <Psi extends PsiElement> Psi[] getStubOrPsiChildren(@Nonnull TokenSet filter, @Nonnull ArrayFactory<? extends Psi> f) {
  T stub = getGreenStub();
  if (stub != null) {
    //noinspection unchecked
    return (Psi[])stub.getChildrenByType(filter, f);
  }
  else {
    final ASTNode[] nodes = getNode().getChildren(filter);
    Psi[] psiElements = f.create(nodes.length);
    for (int i = 0; i < nodes.length; i++) {
      //noinspection unchecked
      psiElements[i] = (Psi)nodes[i].getPsi();
    }
    return psiElements;
  }
}
 

@Nonnull
public <T extends PsiElement> T[] getChildrenAsPsiElements(@Nullable TokenSet filter, @Nonnull ArrayFactory<? extends T> constructor) {
  assertReadAccessAllowed();
  int count = countChildren(filter);
  T[] result = constructor.create(count);
  if (count == 0) {
    return result;
  }
  int idx = 0;
  for (ASTNode child = getFirstChildNode(); child != null && idx < count; child = child.getTreeNext()) {
    if (filter == null || filter.contains(child.getElementType())) {
      @SuppressWarnings("unchecked") T element = (T)child.getPsi();
      LOG.assertTrue(element != null, child);
      result[idx++] = element;
    }
  }
  return result;
}
 

@Nonnull
public <T extends PsiElement> T[] getChildrenAsPsiElements(@Nonnull IElementType type, @Nonnull ArrayFactory<? extends T> constructor) {
  assertReadAccessAllowed();
  int count = countChildren(type);
  T[] result = constructor.create(count);
  if (count == 0) {
    return result;
  }
  int idx = 0;
  for (ASTNode child = getFirstChildNode(); child != null && idx < count; child = child.getTreeNext()) {
    if (type == child.getElementType()) {
      @SuppressWarnings("unchecked") T element = (T)child.getPsi();
      LOG.assertTrue(element != null, child);
      result[idx++] = element;
    }
  }
  return result;
}
 

@Nonnull
@Override
public PsiPackage createPackage(@Nonnull PsiManager psiManager,
                                @Nonnull PsiPackageManager packageManager,
                                @Nonnull Class<? extends ModuleExtension> extensionClass,
                                @Nonnull String packageName) {
  return new PsiPackageBase(psiManager, packageManager, extensionClass, packageName) {
    @Override
    protected ArrayFactory<? extends PsiPackage> getPackageArrayFactory() {
      return PsiPackage.ARRAY_FACTORY;
    }

    @RequiredReadAction
    @Nonnull
    @Override
    public Language getLanguage() {
      return SandLanguage.INSTANCE;
    }
  };
}
 

@Nonnull
@Override
public <E extends PsiElement> E[] getChildrenByType(@Nonnull final IElementType elementType, @Nonnull final ArrayFactory<E> f) {
  List<StubElement> childrenStubs = getChildrenStubs();
  int count = countChildren(elementType, childrenStubs);

  E[] result = f.create(count);
  if (count > 0) fillFilteredChildren(elementType, result, childrenStubs);

  return result;
}
 

@Nonnull
@Override
public <E extends PsiElement> E[] getChildrenByType(@Nonnull final TokenSet filter, @Nonnull final ArrayFactory<E> f) {
  List<StubElement> childrenStubs = getChildrenStubs();
  int count = countChildren(filter, childrenStubs);

  E[] array = f.create(count);
  if (count == 0) return array;

  fillFilteredChildren(filter, array, childrenStubs);

  return array;
}
 

@Nonnull
<E extends PsiElement> E[] getChildrenByType(@Nonnull IElementType elementType, @Nonnull ArrayFactory<E> f);
 

@Nonnull
<E extends PsiElement> E[] getChildrenByType(@Nonnull TokenSet filter, @Nonnull ArrayFactory<E> f);
 

LockFreeCOWSortedArray(@Nonnull Comparator<? super T> comparator, @Nonnull ArrayFactory<T> arrayFactory) {
  this.comparator = comparator;
  this.arrayFactory = arrayFactory;
  listeners = arrayFactory.create(0);
}
 

protected abstract ArrayFactory<? extends PsiPackage> getPackageArrayFactory();