common method extracted
[idea/community.git] / platform / lang-impl / src / com / intellij / openapi / roots / impl / OrderEntryUtil.java
1 /*
2  * Copyright 2000-2009 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.impl;
21
22 import com.intellij.openapi.module.Module;
23 import com.intellij.openapi.projectRoots.Sdk;
24 import com.intellij.openapi.roots.*;
25 import com.intellij.openapi.roots.libraries.Library;
26 import com.intellij.openapi.roots.libraries.LibraryTable;
27 import com.intellij.openapi.util.Comparing;
28 import com.intellij.openapi.vfs.VirtualFile;
29 import com.intellij.util.ArrayUtil;
30 import com.intellij.util.Processor;
31 import org.jetbrains.annotations.NotNull;
32 import org.jetbrains.annotations.Nullable;
33
34 import java.util.ArrayList;
35 import java.util.List;
36
37 public class OrderEntryUtil {
38   private OrderEntryUtil() {
39   }
40
41   @Nullable
42   public static LibraryOrderEntry findLibraryOrderEntry(@NotNull ModuleRootModel model, @Nullable Library library) {
43     if (library == null) return null;
44     for (OrderEntry orderEntry : model.getOrderEntries()) {
45       if (orderEntry instanceof LibraryOrderEntry && library.equals(((LibraryOrderEntry)orderEntry).getLibrary())) {
46         return (LibraryOrderEntry)orderEntry;
47       }
48     }
49
50     return null;
51   }
52
53   @Nullable
54   public static LibraryOrderEntry findLibraryOrderEntry(@NotNull ModuleRootModel model, @NotNull String libraryName) {
55     for (OrderEntry orderEntry : model.getOrderEntries()) {
56       if (orderEntry instanceof LibraryOrderEntry) {
57         final String libName = ((LibraryOrderEntry)orderEntry).getLibraryName();
58         if (libraryName.equals(libName)) {
59           return (LibraryOrderEntry)orderEntry;
60         }
61       }
62     }
63     return null;
64   }
65
66   @Nullable
67   public static ModuleOrderEntry findModuleOrderEntry(@NotNull ModuleRootModel model, @Nullable Module module) {
68     if (module == null) return null;
69
70     for (OrderEntry orderEntry : model.getOrderEntries()) {
71       if (orderEntry instanceof ModuleOrderEntry && module.equals(((ModuleOrderEntry)orderEntry).getModule())) {
72         return (ModuleOrderEntry)orderEntry;
73       }
74     }
75     return null;
76   }
77
78   @Nullable
79   public static JdkOrderEntry findJdkOrderEntry(@NotNull ModuleRootModel model, @Nullable Sdk sdk) {
80     if (sdk == null) return null;
81
82     for (OrderEntry orderEntry : model.getOrderEntries()) {
83       if (orderEntry instanceof JdkOrderEntry && sdk.equals(((JdkOrderEntry)orderEntry).getJdk())) {
84         return (JdkOrderEntry)orderEntry;
85       }
86     }
87     return null;
88   }
89
90   public static boolean equals(OrderEntry orderEntry1, OrderEntry orderEntry2) {
91     if (orderEntry1 instanceof JdkOrderEntry && orderEntry2 instanceof JdkOrderEntry) {
92       final JdkOrderEntry jdkOrderEntry1 = (JdkOrderEntry)orderEntry1;
93       final JdkOrderEntry jdkOrderEntry2 = (JdkOrderEntry)orderEntry2;
94       return Comparing.equal(jdkOrderEntry1.getJdk(), jdkOrderEntry2.getJdk()) &&
95              Comparing.strEqual(jdkOrderEntry1.getJdkName(), jdkOrderEntry2.getJdkName());
96     }
97     if (orderEntry1 instanceof LibraryOrderEntry && orderEntry2 instanceof LibraryOrderEntry) {
98       final LibraryOrderEntry jdkOrderEntry1 = (LibraryOrderEntry)orderEntry1;
99       final LibraryOrderEntry jdkOrderEntry2 = (LibraryOrderEntry)orderEntry2;
100       return Comparing.equal(jdkOrderEntry1.getLibrary(), jdkOrderEntry2.getLibrary());
101     }
102     if (orderEntry1 instanceof ModuleSourceOrderEntry && orderEntry2 instanceof ModuleSourceOrderEntry) {
103       final ModuleSourceOrderEntry jdkOrderEntry1 = (ModuleSourceOrderEntry)orderEntry1;
104       final ModuleSourceOrderEntry jdkOrderEntry2 = (ModuleSourceOrderEntry)orderEntry2;
105       return Comparing.equal(jdkOrderEntry1.getOwnerModule(), jdkOrderEntry2.getOwnerModule());
106     }
107     if (orderEntry1 instanceof ModuleOrderEntry && orderEntry2 instanceof ModuleOrderEntry) {
108       final ModuleOrderEntry jdkOrderEntry1 = (ModuleOrderEntry)orderEntry1;
109       final ModuleOrderEntry jdkOrderEntry2 = (ModuleOrderEntry)orderEntry2;
110       return Comparing.equal(jdkOrderEntry1.getModule(), jdkOrderEntry2.getModule());
111     }
112     return false;
113   }
114
115   public static boolean equals(Library library1, Library library2) {
116     if (library1 == library2) return true;
117     if (library1 == null || library2 == null) return false;
118
119     final LibraryTable table = library1.getTable();
120     if (table != null) {
121       if (library2.getTable() != table) return false;
122       final String name = library1.getName();
123       return name != null && name.equals(library2.getName());
124     }
125
126     if (library2.getTable() != null) return false;
127
128     for (OrderRootType type : OrderRootType.getAllTypes()) {
129       if (!Comparing.equal(library1.getUrls(type), library2.getUrls(type))) {
130         return false;
131       }
132     }
133     return true;
134   }
135
136   public static void addLibraryToRoots(final LibraryOrderEntry libraryOrderEntry, final Module module) {
137     Library library = libraryOrderEntry.getLibrary();
138     if (library == null) return;
139     final ModuleRootManager manager = ModuleRootManager.getInstance(module);
140     final ModifiableRootModel rootModel = manager.getModifiableModel();
141
142     if (libraryOrderEntry.isModuleLevel()) {
143       final Library jarLibrary = rootModel.getModuleLibraryTable().createLibrary();
144       final Library.ModifiableModel libraryModel = jarLibrary.getModifiableModel();
145       for (OrderRootType orderRootType : OrderRootType.getAllTypes()) {
146         VirtualFile[] files = library.getFiles(orderRootType);
147         for (VirtualFile jarFile : files) {
148           libraryModel.addRoot(jarFile, orderRootType);
149         }
150       }
151       libraryModel.commit();
152     }
153     else {
154       rootModel.addLibraryEntry(library);
155     }
156     rootModel.commit();
157   }
158
159   private static int findLibraryOrderEntry(@NotNull OrderEntry[] entries, @NotNull Library library) {
160     for (int i = 0; i < entries.length; i++) {
161       OrderEntry entry = entries[i];
162       if (entry instanceof LibraryOrderEntry && library.equals(((LibraryOrderEntry)entry).getLibrary())) {
163         return i;
164       }
165     }
166     return -1;
167   }
168
169   public static void replaceLibrary(@NotNull ModifiableRootModel model, @NotNull Library oldLibrary, @NotNull Library newLibrary) {
170     int i = findLibraryOrderEntry(model.getOrderEntries(), oldLibrary);
171     if (i == -1) return;
172
173     model.addLibraryEntry(newLibrary);
174     replaceLibraryByAdded(model, i);
175   }
176
177   public static void replaceLibraryEntryByAdded(@NotNull ModifiableRootModel model, @NotNull LibraryOrderEntry entry) {
178     int i = ArrayUtil.indexOf(model.getOrderEntries(), entry);
179     if (i == -1) return;
180
181     replaceLibraryByAdded(model, i);
182   }
183
184   private static void replaceLibraryByAdded(ModifiableRootModel model, int toReplace) {
185     OrderEntry[] entries = model.getOrderEntries();
186     LibraryOrderEntry newEntry = (LibraryOrderEntry)entries[entries.length - 1];
187     LibraryOrderEntry libraryEntry = (LibraryOrderEntry)entries[toReplace];
188     boolean exported = libraryEntry.isExported();
189     DependencyScope scope = libraryEntry.getScope();
190     model.removeOrderEntry(libraryEntry);
191     newEntry.setExported(exported);
192     newEntry.setScope(scope);
193     final OrderEntry[] newEntries = new OrderEntry[entries.length-1];
194     System.arraycopy(entries, 0, newEntries, 0, toReplace);
195     newEntries[toReplace] = newEntry;
196     System.arraycopy(entries, toReplace + 1, newEntries, toReplace + 1, entries.length - toReplace - 2);
197     model.rearrangeOrderEntries(newEntries);
198   }
199
200   public static <T extends OrderEntry> void processOrderEntries(@NotNull Module module,
201                                                                 @NotNull Class<T> orderEntryClass,
202                                                                 @NotNull Processor<T> processor) {
203     OrderEntry[] orderEntries = ModuleRootManager.getInstance(module).getOrderEntries();
204     for (OrderEntry orderEntry : orderEntries) {
205       if (orderEntryClass.isInstance(orderEntry)) {
206         if (!processor.process(orderEntryClass.cast(orderEntry))) {
207           break;
208         }
209       }
210     }
211   }
212
213   public static DependencyScope intersectScopes(DependencyScope scope1, DependencyScope scope2) {
214     if (scope1 == scope2) return scope1;
215     if (scope1 == DependencyScope.COMPILE) return scope2;
216     if (scope2 == DependencyScope.COMPILE) return scope1;
217     if (scope1 == DependencyScope.TEST || scope2 == DependencyScope.TEST) return DependencyScope.TEST;
218     return scope1;
219   }
220
221   @NotNull
222   public static List<Library> getModuleLibraries(@NotNull ModuleRootModel model) {
223     OrderEntry[] orderEntries = model.getOrderEntries();
224     List<Library> libraries = new ArrayList<Library>();
225     for (OrderEntry orderEntry : orderEntries) {
226       if (orderEntry instanceof LibraryOrderEntry) {
227         final LibraryOrderEntry entry = (LibraryOrderEntry)orderEntry;
228         if (entry.isModuleLevel()) {
229           libraries.add(entry.getLibrary());
230         }
231       }
232     }
233     return libraries;
234   }
235 }