public static void removeDuplicates(@NotNull CompositePackagingElement<?> parent) {
List<PackagingElement<?>> prevChildren = new ArrayList<PackagingElement<?>>();
List<PackagingElement<?>> toRemove = new ArrayList<PackagingElement<?>>();
for (PackagingElement<?> child : parent.getChildren()) {
if (child instanceof CompositePackagingElement<?>) {
removeDuplicates((CompositePackagingElement<?>) child);
}
boolean merged = false;
for (PackagingElement<?> prevChild : prevChildren) {
if (child.isEqualTo(prevChild)) {
if (child instanceof CompositePackagingElement<?>) {
for (PackagingElement<?> childElement :
((CompositePackagingElement<?>) child).getChildren()) {
((CompositePackagingElement<?>) prevChild).addOrFindChild(childElement);
}
}
merged = true;
break;
}
}
if (merged) {
toRemove.add(child);
} else {
prevChildren.add(child);
}
}
for (PackagingElement<?> child : toRemove) {
parent.removeChild(child);
}
}
public static void copyChildren(
CompositePackagingElement<?> oldParent,
CompositePackagingElement<?> newParent,
@NotNull Project project) {
for (PackagingElement<?> child : oldParent.getChildren()) {
newParent.addOrFindChild(copyWithChildren(child, project));
}
}
public static void removeChildrenRecursively(
@NotNull CompositePackagingElement<?> element,
@NotNull Condition<PackagingElement<?>> condition) {
List<PackagingElement<?>> toRemove = new ArrayList<PackagingElement<?>>();
for (PackagingElement<?> child : element.getChildren()) {
if (child instanceof CompositePackagingElement<?>) {
final CompositePackagingElement<?> compositeChild = (CompositePackagingElement<?>) child;
removeChildrenRecursively(compositeChild, condition);
if (compositeChild.getChildren().isEmpty()) {
toRemove.add(child);
}
} else if (condition.value(child)) {
toRemove.add(child);
}
}
element.removeChildren(toRemove);
}
public static boolean processElementsByRelativePath(
@NotNull final CompositePackagingElement<?> parent,
@NotNull String relativePath,
@NotNull final PackagingElementResolvingContext context,
@NotNull final ArtifactType artifactType,
@NotNull PackagingElementPath parentPath,
@NotNull final PackagingElementProcessor<PackagingElement<?>> processor) {
relativePath = StringUtil.trimStart(relativePath, "/");
if (relativePath.length() == 0) {
return true;
}
int i = relativePath.indexOf('/');
final String firstName = i != -1 ? relativePath.substring(0, i) : relativePath;
final String tail = i != -1 ? relativePath.substring(i + 1) : "";
return processElementsWithSubstitutions(
parent.getChildren(),
context,
artifactType,
parentPath.appendComposite(parent),
new PackagingElementProcessor<PackagingElement<?>>() {
@Override
public boolean process(
@NotNull PackagingElement<?> element, @NotNull PackagingElementPath path) {
boolean process = false;
if (element instanceof CompositePackagingElement
&& firstName.equals(((CompositePackagingElement<?>) element).getName())) {
process = true;
} else if (element instanceof FileCopyPackagingElement) {
final FileCopyPackagingElement fileCopy = (FileCopyPackagingElement) element;
if (firstName.equals(fileCopy.getOutputFileName())) {
process = true;
}
}
if (process) {
if (tail.length() == 0) {
if (!processor.process(element, path)) return false;
} else if (element instanceof CompositePackagingElement<?>) {
return processElementsByRelativePath(
(CompositePackagingElement) element,
tail,
context,
artifactType,
path,
processor);
}
}
return true;
}
});
}
private static <E extends PackagingElement<?>> boolean processElementRecursively(
@NotNull PackagingElement<?> element,
@Nullable PackagingElementType<E> type,
@NotNull PackagingElementProcessor<? super E> processor,
@NotNull PackagingElementResolvingContext resolvingContext,
final boolean processSubstitutions,
ArtifactType artifactType,
@NotNull PackagingElementPath path,
Set<PackagingElement<?>> processed) {
if (!processor.shouldProcess(element) || !processed.add(element)) {
return true;
}
if (type == null || element.getType().equals(type)) {
if (!processor.process((E) element, path)) {
return false;
}
}
if (element instanceof CompositePackagingElement<?>) {
final CompositePackagingElement<?> composite = (CompositePackagingElement<?>) element;
return processElementsRecursively(
composite.getChildren(),
type,
processor,
resolvingContext,
processSubstitutions,
artifactType,
path.appendComposite(composite),
processed);
} else if (element instanceof ComplexPackagingElement<?> && processSubstitutions) {
final ComplexPackagingElement<?> complexElement = (ComplexPackagingElement<?>) element;
if (processor.shouldProcessSubstitution(complexElement)) {
final List<? extends PackagingElement<?>> substitution =
complexElement.getSubstitution(resolvingContext, artifactType);
if (substitution != null) {
return processElementsRecursively(
substitution,
type,
processor,
resolvingContext,
processSubstitutions,
artifactType,
path.appendComplex(complexElement),
processed);
}
}
}
return true;
}
@Nullable
public static VirtualFile suggestManifestFileDirectory(
@NotNull CompositePackagingElement<?> root,
PackagingElementResolvingContext context,
ArtifactType artifactType) {
final VirtualFile metaInfDir =
ArtifactUtil.findSourceFileByOutputPath(root, MANIFEST_DIR_NAME, context, artifactType);
if (metaInfDir != null) {
return metaInfDir;
}
final Ref<VirtualFile> sourceDir = Ref.create(null);
final Ref<VirtualFile> sourceFile = Ref.create(null);
ArtifactUtil.processElementsWithSubstitutions(
root.getChildren(),
context,
artifactType,
PackagingElementPath.EMPTY,
new PackagingElementProcessor<PackagingElement<?>>() {
@Override
public boolean process(
@NotNull PackagingElement<?> element, @NotNull PackagingElementPath path) {
if (element instanceof FileCopyPackagingElement) {
final VirtualFile file = ((FileCopyPackagingElement) element).findFile();
if (file != null) {
sourceFile.set(file);
}
} else if (element instanceof DirectoryCopyPackagingElement) {
final VirtualFile file = ((DirectoryCopyPackagingElement) element).findFile();
if (file != null) {
sourceDir.set(file);
return false;
}
}
return true;
}
});
if (!sourceDir.isNull()) {
return sourceDir.get();
}
final Project project = context.getProject();
return suggestBaseDir(project, sourceFile.get());
}
private boolean isEnabled() {
if (myLayoutTreeComponent.isSortElements()) {
return false;
}
final PackagingElementNode<?> node = myLayoutTreeComponent.getSelection().getNodeIfSingle();
if (node == null) {
return false;
}
final CompositePackagingElementNode parent = node.getParentNode();
if (parent == null) return false;
final PackagingElement<?> element = node.getElementIfSingle();
final CompositePackagingElement<?> parentElement = parent.getElementIfSingle();
if (parentElement == null || element == null) return false;
final List<PackagingElement<?>> children = parentElement.getChildren();
final int index = children.indexOf(element);
return index != -1 && 0 <= index + myDirection && index + myDirection < children.size();
}
public static List<VirtualFile> findSourceFilesByOutputPath(
CompositePackagingElement<?> parent,
final String outputPath,
final PackagingElementResolvingContext context,
final ArtifactType artifactType) {
final String path = StringUtil.trimStart(outputPath, "/");
if (path.length() == 0) {
return Collections.emptyList();
}
int i = path.indexOf('/');
final String firstName = i != -1 ? path.substring(0, i) : path;
final String tail = i != -1 ? path.substring(i + 1) : "";
final List<VirtualFile> result = new SmartList<VirtualFile>();
processElementsWithSubstitutions(
parent.getChildren(),
context,
artifactType,
PackagingElementPath.EMPTY,
new PackagingElementProcessor<PackagingElement<?>>() {
@Override
public boolean process(
@NotNull PackagingElement<?> element, @NotNull PackagingElementPath elementPath) {
// todo[nik] replace by method findSourceFile() in PackagingElement
if (element instanceof CompositePackagingElement) {
final CompositePackagingElement<?> compositeElement =
(CompositePackagingElement<?>) element;
if (firstName.equals(compositeElement.getName())) {
result.addAll(
findSourceFilesByOutputPath(compositeElement, tail, context, artifactType));
}
} else if (element instanceof FileCopyPackagingElement) {
final FileCopyPackagingElement fileCopyElement = (FileCopyPackagingElement) element;
if (firstName.equals(fileCopyElement.getOutputFileName()) && tail.length() == 0) {
ContainerUtil.addIfNotNull(fileCopyElement.findFile(), result);
}
} else if (element instanceof DirectoryCopyPackagingElement
|| element instanceof ExtractedDirectoryPackagingElement) {
final VirtualFile sourceRoot =
((FileOrDirectoryCopyPackagingElement<?>) element).findFile();
if (sourceRoot != null) {
ContainerUtil.addIfNotNull(sourceRoot.findFileByRelativePath(path), result);
}
} else if (element instanceof ModuleOutputPackagingElement) {
final CompilerConfiguration compilerConfiguration =
CompilerConfiguration.getInstance(context.getProject());
for (VirtualFile sourceRoot :
((ModuleOutputPackagingElement) element).getSourceRoots(context)) {
final VirtualFile sourceFile = sourceRoot.findFileByRelativePath(path);
if (sourceFile != null && compilerConfiguration.isResourceFile(sourceFile)) {
result.add(sourceFile);
}
}
}
return true;
}
});
return result;
}