Java ArrayUtil.EMPTY_OBJECT_ARRAY属性代码示例

@NotNull
public Object[] getVariants() {
    final PsiElement owner = LuaDocCommentUtil.findDocOwner(this);

    ArrayList<Object> candidates = new ArrayList<Object>();
    if (owner instanceof LuaTableConstructor) {
        LuaExpression[] inits = ((LuaTableConstructor) owner).getInitializers();

        for (LuaExpression expr : inits) {
            if (expr instanceof LuaKeyValueInitializer)
                candidates.add(((LuaKeyValueInitializer) expr).getFieldKey());
        }

        return candidates.toArray();
    }

    return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
 

@Override
public final Object[] getChildElements(final Object element) {
  if (element instanceof HierarchyNodeDescriptor) {
    final HierarchyNodeDescriptor descriptor = (HierarchyNodeDescriptor)element;
    final Object[] cachedChildren = descriptor.getCachedChildren();
    if (cachedChildren == null) {
      if (descriptor.isValid()) {
        descriptor.setCachedChildren(buildChildren(descriptor));
      }
      else {
        descriptor.setCachedChildren(ArrayUtil.EMPTY_OBJECT_ARRAY);
      }
    }
    return descriptor.getCachedChildren();
  }
  return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
 

@Override
@NotNull
public Object[] getVariants() {
  final Converter<T> converter = getConverter();
  if (converter instanceof EnumConverter || converter == ResolvingConverter.BOOLEAN_CONVERTER) {
    if (DomCompletionContributor.isSchemaEnumerated(getElement())) return ArrayUtil.EMPTY_OBJECT_ARRAY;
  }

  if (converter instanceof ResolvingConverter) {
    final ResolvingConverter<T> resolvingConverter = (ResolvingConverter<T>)converter;
    ArrayList<Object> result = new ArrayList<Object>();
    final ConvertContext convertContext = getConvertContext();
    for (T variant: resolvingConverter.getVariants(convertContext)) {
      LookupElement lookupElement = resolvingConverter.createLookupElement(variant);
      if (lookupElement != null) {
        result.add(lookupElement);
        continue;
      }
      String name = converter.toString(variant, convertContext);
      if (name != null) {
        result.add(ElementPresentationManager.getInstance().createVariant(variant, name, ((ResolvingConverter)converter).getPsiElement(variant)));
      }
    }
    for (final String string : resolvingConverter.getAdditionalVariants(convertContext)) {
      result.add(LookupValueFactory.createLookupValue(string, null));
    }
    return result.toArray();
  }
  return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
 

private Object[] getApplicableAttributeVariants(PsiElement _context) {
  if (_context instanceof XmlTokenImpl && ((XmlTokenImpl)_context).getTokenType() == XmlTokenType.XML_ATTRIBUTE_VALUE_TOKEN) {
    XmlAttribute attr = PsiTreeUtil.getParentOfType(_context, XmlAttribute.class);
    if (attr != null) {
      final XmlAttributeDescriptor descriptor = attr.getDescriptor();

      if (descriptor != null) {
        if (descriptor.isFixed()) {
          final String defaultValue = descriptor.getDefaultValue();
          return defaultValue == null ? ArrayUtil.EMPTY_OBJECT_ARRAY : new Object[]{defaultValue};
        }

        String[] values = getEnumeratedValues(attr);

        final String[] strings = addSpecificCompletions(attr);

        if (values == null || values.length == 0) {
          values = strings;
        }
        else if (strings != null) {
          values = ArrayUtil.mergeArrays(values, strings);
        }

        return values == null ? ArrayUtil.EMPTY_OBJECT_ARRAY : values;
      }
    }
  }

  return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
 

@NotNull
public Object[] getVariants() {
  final PsiElement owner = LuaDocCommentUtil.findDocOwner(this);
  if (owner instanceof LuaFunctionDefinition) {
    return ((LuaFunctionDefinition)owner).getParameters().getLuaParameters();
  }
  return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
 

@Override
@NotNull
public Object[] getVariants() {
  final Map<String, XmlTag> idMap = getIdMap();
  if (idMap == null) return ArrayUtil.EMPTY_OBJECT_ARRAY;

  String[] variants = idMap.keySet().toArray(new String[idMap.size()]);
  LookupElement[] elements = new LookupElement[variants.length];
  for (int i = 0, variantsLength = variants.length; i < variantsLength; i++) {
    elements[i] = LookupElementBuilder.create(variants[i]).withCaseSensitivity(true);
  }
  return elements;
}
 

@Override
public Object[] get(final PsiElement context, CompletionContext completionContext) {
  XmlTag tag = PsiTreeUtil.getParentOfType(context, XmlTag.class, false);
  if (tag != null) {
    final XmlTag simpleContent = XmlUtil.getSchemaSimpleContent(tag);
    if (simpleContent != null) {
      final HashSet<String> variants = new HashSet<String>();
      XmlUtil.collectEnumerationValues(simpleContent, variants);
      return ArrayUtil.toObjectArray(variants);
    }
  }

  return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
 

@Override
@NotNull
public Object[] getVariants() {
  FileReferenceCompletion completion = FileReferenceCompletion.getInstance();
  if (completion != null) {
    return completion.getFileReferenceCompletionVariants(this);
  }
  return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
 

@NotNull
@Override
public Object[] getVariants() {
  if (StringUtil.isEmptyOrSpaces(myGroupId)) return ArrayUtil.EMPTY_OBJECT_ARRAY;

  MavenProjectIndicesManager manager = MavenProjectIndicesManager.getInstance(getElement().getProject());
  return manager.getArtifactIds(myGroupId).toArray();
}
 

@Override
public Object[] getChildElements(Object element) {
  if (element == myTreeRoot) {
    return myGroups;
  }
  if (element instanceof ResourceGroup) {
    ResourceGroup group = (ResourceGroup)element;
    return group.getItems().toArray();
  }
  return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
 

@Override
public Object[] getChildElements(Object element) {
  if (element == RootDescriptor.ROOT) {
    return ArrayUtil.toStringArray(myCertificates.keySet());
  }
  else if (element instanceof String) {
    return ArrayUtil.toObjectArray(myCertificates.get((String)element));
  }
  return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
 

@NotNull
@Override
public Object[] getDependences()
{
  return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
 

@NotNull
@Override
public Object[] getVariants() {
    return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
 

public Object[] getChildElements(Object nodeElement) {
  if (!(nodeElement instanceof FileElement)) {
    return ArrayUtil.EMPTY_OBJECT_ARRAY;
  }

  FileElement element = (FileElement)nodeElement;
  VirtualFile file = element.getFile();

  if (file == null || !file.isValid()) {
    if (element == myRootElement) {
      return myRootElement.getChildren();
    }
    return ArrayUtil.EMPTY_OBJECT_ARRAY;
  }

  VirtualFile[] children = null;

  if (element.isArchive() && myChooserDescriptor.isChooseJarContents()) {
    String path = file.getPath();
    if (!(file.getFileSystem() instanceof JarFileSystem)) {
      file = JarFileSystem.getInstance().findFileByPath(path + JarFileSystem.JAR_SEPARATOR);
    }
    if (file != null) {
      children = file.getChildren();
    }
  }
  else {
    children = file.getChildren();
  }

  if (children == null) {
    return ArrayUtil.EMPTY_OBJECT_ARRAY;
  }

  Set<FileElement> childrenSet = new HashSet<FileElement>();
  for (VirtualFile child : children) {
    if (myChooserDescriptor.isFileVisible(child, myShowHidden)) {
      final FileElement childElement = new FileElement(child, child.getName());
      childElement.setParent(element);
      childrenSet.add(childElement);
    }
  }
  return ArrayUtil.toObjectArray(childrenSet);
}
 

@Override
public Object[] getChildElements(Object element) {
  if (!(element instanceof AbstractTreeNode)) {
    return ArrayUtil.EMPTY_OBJECT_ARRAY;
  }

  final AbstractTreeNode favTreeElement = (AbstractTreeNode)element;
  try {
    if (!(element instanceof FavoritesListNode)) {
      return super.getChildElements(favTreeElement);
    }

    final List<AbstractTreeNode> result = new ArrayList<AbstractTreeNode>();
    final FavoritesListNode listNode = (FavoritesListNode)element;
    if (listNode.getProvider() != null) {
      return ArrayUtil.toObjectArray(listNode.getChildren());
    }
    final Collection<AbstractTreeNode> roots = FavoritesListNode.getFavoritesRoots(myProject, listNode.getName(), listNode);
    for (AbstractTreeNode<?> abstractTreeNode : roots) {
      final Object value = abstractTreeNode.getValue();

      if (value == null) continue;
      if (value instanceof PsiElement && !((PsiElement)value).isValid()) continue;
      if (value instanceof SmartPsiElementPointer && ((SmartPsiElementPointer)value).getElement() == null) continue;

      boolean invalid = false;
      for (FavoriteNodeProvider nodeProvider : Extensions.getExtensions(FavoriteNodeProvider.EP_NAME, myProject)) {
        if (nodeProvider.isInvalidElement(value)) {
          invalid = true;
          break;
        }
      }
      if (invalid) continue;

      result.add(abstractTreeNode);
    }
    //myFavoritesRoots = result;
    //if (result.isEmpty()) {
    //  result.add(getEmptyScreen());
    //}
    return ArrayUtil.toObjectArray(result);
  }
  catch (Exception e) {
  }

  return ArrayUtil.EMPTY_OBJECT_ARRAY;
}