Android: Remove `kotlin-gradle-tooling.jar` from excludes
[idea/community.git] / platform / projectModel-api / src / com / intellij / openapi / roots / OrderEnumerator.java
1 /*
2  * Copyright 2000-2017 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 package com.intellij.openapi.roots;
17
18 import com.intellij.openapi.module.Module;
19 import com.intellij.openapi.project.Project;
20 import com.intellij.openapi.roots.libraries.Library;
21 import com.intellij.openapi.util.Condition;
22 import com.intellij.openapi.vfs.VirtualFile;
23 import com.intellij.util.NotNullFunction;
24 import com.intellij.util.PathsList;
25 import com.intellij.util.Processor;
26 import org.jetbrains.annotations.ApiStatus;
27 import org.jetbrains.annotations.NotNull;
28
29 import java.util.List;
30
31 /**
32  * <p>Interface for convenient processing dependencies of a module or a project. Allows to process {@link OrderEntry}s
33  * and collect classes and source roots.</p>
34  *
35  * <p>Use {@link #orderEntries(Module)} or {@link ModuleRootModel#orderEntries()} to process dependencies of a module
36  * and use {@link #orderEntries(Project)} to process dependencies of all modules in a project.</p>
37  *
38  * <p>Note that all configuration methods modify {@link OrderEnumerator} instance instead of creating a new one.</p>
39  */
40 @ApiStatus.NonExtendable
41 public abstract class OrderEnumerator {
42   /**
43    * Skip test dependencies
44    *
45    * @return this instance
46    */
47   @NotNull
48   public abstract OrderEnumerator productionOnly();
49
50   /**
51    * Skip runtime-only dependencies
52    *
53    * @return this instance
54    */
55   @NotNull
56   public abstract OrderEnumerator compileOnly();
57
58   /**
59    * Skip compile-only dependencies
60    *
61    * @return this instance
62    */
63   @NotNull
64   public abstract OrderEnumerator runtimeOnly();
65
66   @NotNull
67   public abstract OrderEnumerator withoutSdk();
68
69   @NotNull
70   public abstract OrderEnumerator withoutLibraries();
71
72   @NotNull
73   public abstract OrderEnumerator withoutDepModules();
74
75   /**
76    * Skip root module's entries
77    * @return this
78    */
79   @NotNull
80   public abstract OrderEnumerator withoutModuleSourceEntries();
81
82   @NotNull
83   public OrderEnumerator librariesOnly() {
84     return withoutSdk().withoutDepModules().withoutModuleSourceEntries();
85   }
86
87   @NotNull
88   public OrderEnumerator sdkOnly() {
89     return withoutDepModules().withoutLibraries().withoutModuleSourceEntries();
90   }
91
92   public VirtualFile @NotNull [] getAllLibrariesAndSdkClassesRoots() {
93     return withoutModuleSourceEntries().withoutDepModules().recursively().exportedOnly().classes().usingCache().getRoots();
94   }
95
96   public VirtualFile @NotNull [] getAllSourceRoots() {
97     return recursively().exportedOnly().sources().usingCache().getRoots();
98   }
99
100   /**
101    * Recursively process modules on which the module depends. This flag is ignored for modules imported from Maven because for such modules
102    * transitive dependencies are propagated to the root module during importing.
103    *
104    * @return this instance
105    */
106   @NotNull
107   public abstract OrderEnumerator recursively();
108
109   /**
110    * Skip not exported dependencies. If this method is called after {@link #recursively()} direct non-exported dependencies won't be skipped
111    *
112    * @return this instance
113    */
114   @NotNull
115   public abstract OrderEnumerator exportedOnly();
116
117   /**
118    * Process only entries which satisfies the specified condition
119    *
120    * @param condition filtering condition
121    * @return this instance
122    */
123   @NotNull
124   public abstract OrderEnumerator satisfying(@NotNull Condition<? super OrderEntry> condition);
125
126   /**
127    * Use {@code provider.getRootModel()} to process module dependencies
128    *
129    * @param provider provider
130    * @return this instance
131    */
132   @NotNull
133   public abstract OrderEnumerator using(@NotNull RootModelProvider provider);
134
135   /**
136    * Determine if, given the current enumerator settings and handlers for a module, should the
137    * enumerator recurse to further modules based on the given ModuleOrderEntry?
138    *
139    * @param entry the ModuleOrderEntry in question (m1 -> m2)
140    * @param handlers custom handlers registered to the module
141    * @return true if the enumerator would have recursively processed the given ModuleOrderEntry.
142    */
143   public abstract boolean shouldRecurse(@NotNull ModuleOrderEntry entry, @NotNull List<? extends OrderEnumerationHandler> handlers);
144
145   /**
146    * @return {@link OrderRootsEnumerator} instance for processing classes roots
147    */
148   @NotNull
149   public abstract OrderRootsEnumerator classes();
150
151   /**
152    * @return {@link OrderRootsEnumerator} instance for processing source roots
153    */
154   @NotNull
155   public abstract OrderRootsEnumerator sources();
156
157   /**
158    * @param rootType root type
159    * @return {@link OrderRootsEnumerator} instance for processing roots of the specified type
160    */
161   @NotNull
162   public abstract OrderRootsEnumerator roots(@NotNull OrderRootType rootType);
163
164   /**
165    * @param rootTypeProvider custom root type provider
166    * @return {@link OrderRootsEnumerator} instance for processing roots of the provided type
167    */
168   @NotNull
169   public abstract OrderRootsEnumerator roots(@NotNull NotNullFunction<? super OrderEntry, ? extends OrderRootType> rootTypeProvider);
170
171   /**
172    * @return classes roots for all entries processed by this enumerator
173    */
174   public VirtualFile @NotNull [] getClassesRoots() {
175     return classes().getRoots();
176   }
177
178   /**
179    * @return source roots for all entries processed by this enumerator
180    */
181   public VirtualFile @NotNull [] getSourceRoots() {
182     return sources().getRoots();
183   }
184
185   /**
186    * @return list containing classes roots for all entries processed by this enumerator
187    */
188   @NotNull
189   public PathsList getPathsList() {
190     return classes().getPathsList();
191   }
192
193   /**
194    * @return list containing source roots for all entries processed by this enumerator
195    */
196   @NotNull
197   public PathsList getSourcePathsList() {
198     return sources().getPathsList();
199   }
200
201   /**
202    * Runs {@code processor.process()} for each entry processed by this enumerator.
203    *
204    * @param processor processor
205    */
206   public abstract void forEach(@NotNull Processor<? super OrderEntry> processor);
207
208   /**
209    * Runs {@code processor.process()} for each library processed by this enumerator.
210    *
211    * @param processor processor
212    */
213   public abstract void forEachLibrary(@NotNull Processor<? super Library> processor);
214
215   /**
216    * Runs {@code processor.process()} for each module processed by this enumerator.
217    *
218    * @param processor processor
219    */
220   public abstract void forEachModule(@NotNull Processor<? super Module> processor);
221
222   /**
223    * Passes order entries to the specified visitor.
224    *
225    * @param policy       the visitor to accept.
226    * @param initialValue the default value to be returned by the visit process.
227    * @return the value returned by the visitor.
228    * @see OrderEntry#accept(RootPolicy, Object)
229    */
230   public abstract <R> R process(@NotNull RootPolicy<R> policy, R initialValue);
231
232   /**
233    * Creates new enumerator instance to process dependencies of {@code module}
234    *
235    * @param module module
236    * @return new enumerator instance
237    */
238   @NotNull
239   public static OrderEnumerator orderEntries(@NotNull Module module) {
240     return ModuleRootManager.getInstance(module).orderEntries();
241   }
242
243   /**
244    * Creates new enumerator instance to process dependencies of all modules in {@code project}. Only first level dependencies of
245    * modules are processed so {@link #recursively()} option is ignored and {@link #withoutDepModules()} option is forced
246    *
247    * @param project project
248    * @return new enumerator instance
249    */
250   @NotNull
251   public static OrderEnumerator orderEntries(@NotNull Project project) {
252     return ProjectRootManager.getInstance(project).orderEntries();
253   }
254 }