Package com.intellij.openapi.roots.impl

Class ProjectOrderEnumerator

java.lang.Object

com.intellij.openapi.roots.OrderEnumerator

com.intellij.openapi.roots.impl.ProjectOrderEnumerator

All Implemented Interfaces:

OrderEnumeratorSettings

public class ProjectOrderEnumerator
extends OrderEnumerator

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	OrderEnumeratorBase.ProcessEntryAction
protected static class	OrderEnumeratorBase.ProcessEntryActionType

Constructor Summary

Constructors

Constructor and Description
ProjectOrderEnumerator(Project project, OrderRootsCache rootsCache)

Method Summary

Modifier and Type	Method and Description
OrderRootsEnumerator	classes()
OrderEnumerator	compileOnly() Skip runtime-only dependencies
OrderEnumerator	exportedOnly() Skip not exported dependencies.
protected void	forEach(PairProcessor<? super OrderEntry,? super java.util.List<? extends OrderEnumerationHandler>> processor)
void	forEach(Processor<? super OrderEntry> processor) Runs processor.process() for each entry processed by this enumerator.
void	forEachLibrary(Processor<? super Library> processor) Runs processor.process() for each library processed by this enumerator.
void	forEachModule(Processor<? super Module> processor) Runs processor.process() for each module processed by this enumerator.
int	getFlags()
boolean	isCompileOnly()
boolean	isProductionOnly()
boolean	isRootModuleModel(ModuleRootModel rootModel)
boolean	isRuntimeOnly()
<R> R	process(RootPolicy<R> policy, R initialValue) Passes order entries to the specified visitor.
protected void	processEntries(ModuleRootModel rootModel, java.util.Set<? super Module> processed, boolean firstLevel, java.util.List<? extends OrderEnumerationHandler> customHandlers, PairProcessor<? super OrderEntry,? super java.util.List<? extends OrderEnumerationHandler>> processor)
void	processRootModules(Processor<? super Module> processor) Runs processor on each module that this enumerator was created on.
OrderEnumerator	productionOnly() Skip test dependencies
OrderEnumerator	recursively() Recursively process modules on which the module depends.
OrderRootsEnumerator	roots(NotNullFunction<? super OrderEntry,? extends OrderRootType> rootTypeProvider)
OrderRootsEnumerator	roots(OrderRootType rootType)
OrderEnumerator	runtimeOnly() Skip compile-only dependencies
OrderEnumerator	satisfying(Condition<? super OrderEntry> condition) Process only entries which satisfies the specified condition
boolean	shouldRecurse(ModuleOrderEntry entry, java.util.List<? extends OrderEnumerationHandler> handlers) Determine if, given the current enumerator settings and handlers for a module, should the enumerator recurse to further modules based on the given ModuleOrderEntry?
OrderRootsEnumerator	sources()
OrderEnumerator	using(RootModelProvider provider) Use provider.getRootModel() to process module dependencies
OrderEnumerator	withoutDepModules()
OrderEnumerator	withoutLibraries()
OrderEnumerator	withoutModuleSourceEntries() Skip root module's entries
OrderEnumerator	withoutSdk()

Methods inherited from class com.intellij.openapi.roots.OrderEnumerator

getAllLibrariesAndSdkClassesRoots, getAllSourceRoots, getClassesRoots, getPathsList, getSourcePathsList, getSourceRoots, librariesOnly, orderEntries, orderEntries, sdkOnly

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ProjectOrderEnumerator

public ProjectOrderEnumerator(Project project,
                              OrderRootsCache rootsCache)

Method Detail

processRootModules

public void processRootModules(Processor<? super Module> processor)

Runs processor on each module that this enumerator was created on.

Parameters:

processor - processor

forEach

protected void forEach(PairProcessor<? super OrderEntry,? super java.util.List<? extends OrderEnumerationHandler>> processor)

forEachModule

public void forEachModule(Processor<? super Module> processor)

Description copied from class: OrderEnumerator

Runs processor.process() for each module processed by this enumerator.

Parameters:

processor - processor

isRootModuleModel

public boolean isRootModuleModel(ModuleRootModel rootModel)

productionOnly

public OrderEnumerator productionOnly()

Description copied from class: OrderEnumerator

Skip test dependencies

Specified by:

productionOnly in class OrderEnumerator

Returns:

this instance

compileOnly

public OrderEnumerator compileOnly()

Description copied from class: OrderEnumerator

Skip runtime-only dependencies

Specified by:

compileOnly in class OrderEnumerator

Returns:

this instance

runtimeOnly

public OrderEnumerator runtimeOnly()

Description copied from class: OrderEnumerator

Skip compile-only dependencies

Specified by:

runtimeOnly in class OrderEnumerator

Returns:

this instance

withoutSdk

public OrderEnumerator withoutSdk()

Specified by:

withoutSdk in class OrderEnumerator

withoutLibraries

public OrderEnumerator withoutLibraries()

Specified by:

withoutLibraries in class OrderEnumerator

withoutDepModules

public OrderEnumerator withoutDepModules()

Specified by:

withoutDepModules in class OrderEnumerator

withoutModuleSourceEntries

public OrderEnumerator withoutModuleSourceEntries()

Description copied from class: OrderEnumerator

Skip root module's entries

Specified by:

withoutModuleSourceEntries in class OrderEnumerator

Returns:

this

recursively

public OrderEnumerator recursively()

Description copied from class: OrderEnumerator

Recursively process modules on which the module depends. This flag is ignored for modules imported from Maven because for such modules transitive dependencies are propagated to the root module during importing.

Specified by:

recursively in class OrderEnumerator

Returns:

this instance

exportedOnly

public OrderEnumerator exportedOnly()

Description copied from class: OrderEnumerator

Skip not exported dependencies. If this method is called after OrderEnumerator.recursively() direct non-exported dependencies won't be skipped

Specified by:

exportedOnly in class OrderEnumerator

Returns:

this instance

satisfying

public OrderEnumerator satisfying(Condition<? super OrderEntry> condition)

Description copied from class: OrderEnumerator

Process only entries which satisfies the specified condition

Specified by:

satisfying in class OrderEnumerator

Parameters:

condition - filtering condition

Returns:

this instance

using

public OrderEnumerator using(RootModelProvider provider)

Description copied from class: OrderEnumerator

Use provider.getRootModel() to process module dependencies

Specified by:

using in class OrderEnumerator

Parameters:

provider - provider

Returns:

this instance

classes

public OrderRootsEnumerator classes()

Specified by:

classes in class OrderEnumerator

Returns:

OrderRootsEnumerator instance for processing classes roots

sources

public OrderRootsEnumerator sources()

Specified by:

sources in class OrderEnumerator

Returns:

OrderRootsEnumerator instance for processing source roots

roots

public OrderRootsEnumerator roots(OrderRootType rootType)

Specified by:

roots in class OrderEnumerator

Parameters:

rootType - root type

Returns:

OrderRootsEnumerator instance for processing roots of the specified type

roots

public OrderRootsEnumerator roots(NotNullFunction<? super OrderEntry,? extends OrderRootType> rootTypeProvider)

Specified by:

roots in class OrderEnumerator

Parameters:

rootTypeProvider - custom root type provider

Returns:

OrderRootsEnumerator instance for processing roots of the provided type

getFlags

public int getFlags()

shouldRecurse

public boolean shouldRecurse(ModuleOrderEntry entry,
                             java.util.List<? extends OrderEnumerationHandler> handlers)

Description copied from class: OrderEnumerator

Determine if, given the current enumerator settings and handlers for a module, should the enumerator recurse to further modules based on the given ModuleOrderEntry?

Specified by:

shouldRecurse in class OrderEnumerator

Parameters:

entry - the ModuleOrderEntry in question (m1 -> m2)

handlers - custom handlers registered to the module

Returns:

true if the enumerator would have recursively processed the given ModuleOrderEntry.

processEntries

protected void processEntries(ModuleRootModel rootModel,
                              java.util.Set<? super Module> processed,
                              boolean firstLevel,
                              java.util.List<? extends OrderEnumerationHandler> customHandlers,
                              PairProcessor<? super OrderEntry,? super java.util.List<? extends OrderEnumerationHandler>> processor)

forEach

public void forEach(Processor<? super OrderEntry> processor)

Description copied from class: OrderEnumerator

Runs processor.process() for each entry processed by this enumerator.

Specified by:

forEach in class OrderEnumerator

Parameters:

processor - processor

forEachLibrary

public void forEachLibrary(Processor<? super Library> processor)

Description copied from class: OrderEnumerator

Runs processor.process() for each library processed by this enumerator.

Specified by:

forEachLibrary in class OrderEnumerator

Parameters:

processor - processor

process

public <R> R process(RootPolicy<R> policy,
                     R initialValue)

Description copied from class: OrderEnumerator

Passes order entries to the specified visitor.

Specified by:

process in class OrderEnumerator

Parameters:

policy - the visitor to accept.

initialValue - the default value to be returned by the visit process.

Returns:

the value returned by the visitor.

See Also:

OrderEntry.accept(RootPolicy, Object)

isRuntimeOnly

public boolean isRuntimeOnly()

Specified by:

isRuntimeOnly in interface OrderEnumeratorSettings

isCompileOnly

public boolean isCompileOnly()

Specified by:

isCompileOnly in interface OrderEnumeratorSettings

isProductionOnly

public boolean isProductionOnly()

Specified by:

isProductionOnly in interface OrderEnumeratorSettings