com.intellij.openapi.externalSystem.model.Key Java Examples

@SuppressWarnings("unchecked")
public <T> void importData(@Nonnull Key<T> key, @Nonnull Collection<DataNode<T>> nodes, @Nonnull Project project, boolean synchronous) {
  ensureTheDataIsReadyToUse(nodes);
  List<ProjectDataService<?, ?>> services = myServices.getValue().get(key);
  if (services == null) {
    LOG.warn(String.format(
      "Can't import data nodes '%s'. Reason: no service is registered for key %s. Available services for %s",
      nodes, key, myServices.getValue().keySet()
    ));
  }
  else {
    for (ProjectDataService<?, ?> service : services) {
      ((ProjectDataService<T, ?>)service).importData(nodes, project, synchronous);
    }
  }

  Collection<DataNode<?>> children = ContainerUtilRt.newArrayList();
  for (DataNode<T> node : nodes) {
    children.addAll(node.getChildren());
  }
  importData(children, project, synchronous);
}
 

@SuppressWarnings("unchecked")
private <T> void ensureTheDataIsReadyToUse(@Nonnull Collection<DataNode<T>> nodes) {
  Map<Key<?>, List<ProjectDataService<?, ?>>> servicesByKey = myServices.getValue();
  Stack<DataNode<T>> toProcess = ContainerUtil.newStack(nodes);
  while (!toProcess.isEmpty()) {
    DataNode<T> node = toProcess.pop();
    List<ProjectDataService<?, ?>> services = servicesByKey.get(node.getKey());
    if (services != null) {
      for (ProjectDataService<?, ?> service : services) {
        node.prepareData(service.getClass().getClassLoader());
      }
    }

    for (DataNode<?> dataNode : node.getChildren()) {
      toProcess.push((DataNode<T>)dataNode);
    }
  }
}
 

@SuppressWarnings("unchecked")
@Nonnull
public static <T> Collection<DataNode<T>> getChildren(@Nonnull DataNode<?> node, @Nonnull Key<T> key) {
  Collection<DataNode<T>> result = null;
  for (DataNode<?> child : node.getChildren()) {
    if (!key.equals(child.getKey())) {
      continue;
    }
    if (result == null) {
      result = ContainerUtilRt.newArrayList();
    }
    result.add((DataNode<T>)child);
  }
  return result == null ? Collections.<DataNode<T>>emptyList() : result;
}
 

@SuppressWarnings("unchecked")
public <T> void importData(@Nonnull Collection<DataNode<?>> nodes, @Nonnull Project project, boolean synchronous) {
  Map<Key<?>, List<DataNode<?>>> grouped = ExternalSystemApiUtil.group(nodes);
  for (Map.Entry<Key<?>, List<DataNode<?>>> entry : grouped.entrySet()) {
    // Simple class cast makes ide happy but compiler fails.
    Collection<DataNode<T>> dummy = ContainerUtilRt.newArrayList();
    for (DataNode<?> node : entry.getValue()) {
      dummy.add((DataNode<T>)node);
    }
    importData((Key<T>)entry.getKey(), dummy, project, synchronous);
  }
}
 

@SuppressWarnings("unchecked")
@Nonnull
public static <T> Collection<DataNode<T>> findAll(@Nonnull DataNode<?> parent, @Nonnull Key<T> key) {
  Collection<DataNode<T>> result = null;
  for (DataNode<?> child : parent.getChildren()) {
    if (!key.equals(child.getKey())) {
      continue;
    }
    if (result == null) {
      result = ContainerUtilRt.newArrayList();
    }
    result.add((DataNode<T>)child);
  }
  return result == null ? Collections.<DataNode<T>>emptyList() : result;
}
 

@SuppressWarnings("unchecked")
@javax.annotation.Nullable
public static <T> DataNode<T> findParent(@Nonnull DataNode<?> node, @Nonnull Key<T> key, @Nullable BooleanFunction<DataNode<T>> predicate) {
  DataNode<?> parent = node.getParent();
  if (parent == null) return null;
  return key.equals(parent.getKey()) && (predicate == null || predicate.fun((DataNode<T>)parent)) ? (DataNode<T>)parent : findParent(parent, key, predicate);
}
 

@SuppressWarnings("unchecked")
public <T> void removeData(@Nonnull Key<?> key, @Nonnull Collection<T> toRemove, @Nonnull Project project, boolean synchronous) {
  List<ProjectDataService<?, ?>> services = myServices.getValue().get(key);
  for (ProjectDataService<?, ?> service : services) {
    ((ProjectDataService<?, T>)service).removeData(toRemove, project, synchronous);
  }
}
 

@SuppressWarnings("unchecked")
@javax.annotation.Nullable
public static <T> DataNode<T> find(@Nonnull DataNode<?> node, @Nonnull Key<T> key, BooleanFunction<DataNode<T>> predicate) {
  for (DataNode<?> child : node.getChildren()) {
    if (key.equals(child.getKey()) && predicate.fun((DataNode<T>)child)) {
      return (DataNode<T>)child;
    }
  }
  return null;
}
 

@SuppressWarnings("unchecked")
@javax.annotation.Nullable
public static <T> DataNode<T> find(@Nonnull DataNode<?> node, @Nonnull Key<T> key) {
  for (DataNode<?> child : node.getChildren()) {
    if (key.equals(child.getKey())) {
      return (DataNode<T>)child;
    }
  }
  return null;
}
 

@Nonnull
public static <K, V> Map<DataNode<K>, List<DataNode<V>>> groupBy(@Nonnull Collection<DataNode<V>> nodes, @Nonnull final Key<K> key) {
  return groupBy(nodes, new NullableFunction<DataNode<V>, DataNode<K>>() {
    @Nullable
    @Override
    public DataNode<K> fun(DataNode<V> node) {
      return node.getDataNode(key);
    }
  });
}
 

@NotNull
public static <T> List<T> findChildren(@NotNull DataNode<?> dataNode, @NotNull Key<T> key) {
  return ContainerUtil.mapNotNull(
    ExternalSystemApiUtil.findAll(dataNode, key),
    new Function<DataNode<T>, T>() {
      @Override
      public T fun(DataNode<T> node) {
        return node.getData();
      }
    }
  );
}
 

@Nonnull
@Override
public Key<ModuleData> getTargetDataKey() {
  return ProjectKeys.MODULE;
}
 

@Nonnull
@Override
public Key<ProjectData> getTargetDataKey() {
  return ProjectKeys.PROJECT;
}
 

@Nonnull
@Override
public Key<ModuleData> getTargetDataKey() {
  return ProjectKeys.MODULE;
}
 

@Nonnull
@Override
public Key<LibraryData> getTargetDataKey() {
  return ProjectKeys.LIBRARY;
}
 

@Nonnull
@Override
public Key<LibraryDependencyData> getTargetDataKey() {
  return ProjectKeys.LIBRARY_DEPENDENCY;
}
 

@Nonnull
@Override
public Key<TaskData> getTargetDataKey() {
  return ProjectKeys.TASK;
}
 

@NotNull
@Override
public Key<LibraryDependencyData> getTargetDataKey() {
    return ProjectKeys.LIBRARY_DEPENDENCY;
}
 

@Nonnull
@Override
public Key<ContentRootData> getTargetDataKey() {
  return ProjectKeys.CONTENT_ROOT;
}
 

@Nonnull
@Override
public Key<ModuleDependencyData> getTargetDataKey() {
  return ProjectKeys.MODULE_DEPENDENCY;
}
 

@SuppressWarnings("unchecked")
@Nullable
public static <T> DataNode<T> findParent(@Nonnull DataNode<?> node, @Nonnull Key<T> key) {
  return findParent(node, key, null);
}
 

@Nonnull
public static Map<Key<?>, List<DataNode<?>>> group(@Nonnull Collection<DataNode<?>> nodes) {
  return groupBy(nodes, GROUPER);
}
 

@Override
public Key<?> fun(DataNode<?> node) {
  return node.getKey();
}
 

@NotNull
@Override
public Key<PythonSetupData> getTargetDataKey() {
  return PythonSetupData.KEY;
}
 

@NotNull
@Override
public Key<TargetMetadata> getTargetDataKey() {
  return TargetMetadata.KEY;
}
 

@NotNull
@Override
public Key<ModuleData> getTargetDataKey() {
  return ProjectKeys.MODULE;
}
 

/**
 * @return key of project data supported by the current manager
 */
@Nonnull
Key<E> getTargetDataKey();