lvcs-impl
[idea/community.git] / lang-api / src / com / intellij / openapi / roots / libraries / LibraryUtil.java
1 /*
2  * Copyright 2000-2007 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 /**
18  * @author cdr
19  */
20 package com.intellij.openapi.roots.libraries;
21
22 import com.intellij.openapi.module.Module;
23 import com.intellij.openapi.module.ModuleManager;
24 import com.intellij.openapi.project.Project;
25 import com.intellij.openapi.roots.*;
26 import com.intellij.openapi.vfs.VirtualFile;
27 import com.intellij.util.containers.HashSet;
28 import com.intellij.util.text.StringTokenizer;
29 import org.jetbrains.annotations.NonNls;
30 import org.jetbrains.annotations.Nullable;
31
32 import java.util.Arrays;
33 import java.util.Set;
34
35 public class LibraryUtil {
36   private LibraryUtil() {
37   }
38
39   public static boolean isClassAvailableInLibrary(final Library library, final String fqn) {
40     return isClassAvailableInLibrary(library.getFiles(OrderRootType.CLASSES), fqn);
41   }
42
43   public static boolean isClassAvailableInLibrary(VirtualFile[] files, final String fqn) {
44     for (VirtualFile file : files) {
45       if (findInFile(file, new StringTokenizer(fqn, "."))) return true;
46     }
47     return false;
48   }
49
50   @Nullable
51   public static Library findLibraryByClass(final String fqn, @Nullable Project project) {
52     if (project != null) {
53       final LibraryTable projectTable = LibraryTablesRegistrar.getInstance().getLibraryTable(project);
54       Library library = findInTable(projectTable, fqn);
55       if (library != null) {
56         return library;
57       }
58     }
59     final LibraryTable table = LibraryTablesRegistrar.getInstance().getLibraryTable();
60     return findInTable(table, fqn);
61   }
62
63
64   private static boolean findInFile(VirtualFile file, final StringTokenizer tokenizer) {
65     if (!tokenizer.hasMoreTokens()) return true;
66     @NonNls StringBuilder name = new StringBuilder(tokenizer.nextToken());
67     if (!tokenizer.hasMoreTokens()) {
68       name.append(".class");
69     }
70     final VirtualFile child = file.findChild(name.toString());
71     return child != null && findInFile(child, tokenizer);
72   }
73
74   @Nullable
75   private static Library findInTable(LibraryTable table, String fqn) {
76     for (Library library : table.getLibraries()) {
77       if (isClassAvailableInLibrary(library, fqn)) {
78         return library;
79       }
80     }
81     return null;
82   }
83
84   public static Library createLibrary(final LibraryTable libraryTable, @NonNls final String baseName) {
85     String name = baseName;
86     int count = 2;
87     while (libraryTable.getLibraryByName(name) != null) {
88       name = baseName + " (" + count++ + ")";
89     }
90     return libraryTable.createLibrary(name);
91   }
92
93   public static VirtualFile[] getLibraryRoots(final Project project) {
94     return getLibraryRoots(project, true, true);
95   }
96
97   public static VirtualFile[] getLibraryRoots(final Project project, final boolean includeSourceFiles, final boolean includeJdk) {
98     return getLibraryRoots(ModuleManager.getInstance(project).getModules(), includeSourceFiles, includeJdk);
99   }
100
101   public static VirtualFile[] getLibraryRoots(final Module[] modules, final boolean includeSourceFiles, final boolean includeJdk) {
102     Set<VirtualFile> roots = new HashSet<VirtualFile>();
103     for (Module module : modules) {
104       final ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(module);
105       final OrderEntry[] orderEntries = moduleRootManager.getOrderEntries();
106       for (OrderEntry entry : orderEntries) {
107         if (entry instanceof LibraryOrderEntry){
108           final Library library = ((LibraryOrderEntry)entry).getLibrary();
109           if (library != null) {
110             VirtualFile[] files = includeSourceFiles ? library.getFiles(OrderRootType.SOURCES) : null;
111             if (files == null || files.length == 0){
112               files = library.getFiles(OrderRootType.CLASSES);
113             }
114             roots.addAll(Arrays.asList(files));
115           }
116         } else if (includeJdk && entry instanceof JdkOrderEntry){
117           VirtualFile[] files = includeSourceFiles ? entry.getFiles(OrderRootType.SOURCES) : null;
118           if (files == null || files.length == 0){
119             files = entry.getFiles(OrderRootType.CLASSES);
120           }
121           roots.addAll(Arrays.asList(files));
122         }
123       }
124     }
125     return roots.toArray(new VirtualFile[roots.size()]);
126   }
127
128   public static Library findLibrary(Module module, final String name) {
129     return ModuleRootManager.getInstance(module).processOrder(new RootPolicy<Library>(){
130       @Override
131       public Library visitLibraryOrderEntry(LibraryOrderEntry libraryOrderEntry, Library value) {
132         if (value != null) return value;
133         if (name.equals(libraryOrderEntry.getLibraryName())) {
134           return libraryOrderEntry.getLibrary();
135         }
136         return null;
137       }
138     }, null);
139   }
140 }