OrderEnumerator (Unofficial IntelliJ Community Edition API docs)

java.lang.Object
- com.intellij.openapi.roots.OrderEnumerator

Direct Known Subclasses:

ModuleOrderEnumerator, ModulesOrderEnumerator, ProjectOrderEnumerator
```
public abstract class OrderEnumerator
extends java.lang.Object
```
Interface for convenient processing dependencies of a module or a project. Allows to process OrderEntrys and collect classes and source roots.

Use orderEntries(Module) or ModuleRootModel.orderEntries() to process dependencies of a module and use orderEntries(Project) to process dependencies of all modules in a project.

Note that all configuration methods modify OrderEnumerator instance instead of creating a new one.

Constructor Summary

Constructors
Constructor and Description

OrderEnumerator()

Constructors
Constructor and Description
`OrderEnumerator()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`abstract OrderRootsEnumerator`	`classes()`
`abstract OrderEnumerator`	`compileOnly()` Skip runtime-only dependencies
`abstract OrderEnumerator`	`exportedOnly()` Skip not exported dependencies.
`abstract void`	`forEach(Processor<? super OrderEntry> processor)` Runs `processor.process()` for each entry processed by this enumerator.
`abstract void`	`forEachLibrary(Processor<? super Library> processor)` Runs `processor.process()` for each library processed by this enumerator.
`abstract void`	`forEachModule(Processor<? super Module> processor)` Runs `processor.process()` for each module processed by this enumerator.
`VirtualFile []`	`getAllLibrariesAndSdkClassesRoots()`
`VirtualFile []`	`getAllSourceRoots()`
`VirtualFile []`	`getClassesRoots()`
`PathsList`	`getPathsList()`
`PathsList`	`getSourcePathsList()`
`VirtualFile []`	`getSourceRoots()`
`OrderEnumerator`	`librariesOnly()`
`static OrderEnumerator`	`orderEntries(Module module)` Creates new enumerator instance to process dependencies of `module`
`static OrderEnumerator`	`orderEntries(Project project)` Creates new enumerator instance to process dependencies of all modules in `project`.
`abstract <R> R`	`process(RootPolicy<R> policy, R initialValue)` Passes order entries to the specified visitor.
`abstract OrderEnumerator`	`productionOnly()` Skip test dependencies
`abstract OrderEnumerator`	`recursively()` Recursively process modules on which the module depends.
`abstract OrderRootsEnumerator`	`roots(NotNullFunction<? super OrderEntry,? extends OrderRootType> rootTypeProvider)`
`abstract OrderRootsEnumerator`	`roots(OrderRootType rootType)`
`abstract OrderEnumerator`	`runtimeOnly()` Skip compile-only dependencies
`abstract OrderEnumerator`	`satisfying(Condition<? super OrderEntry> condition)` Process only entries which satisfies the specified condition
`OrderEnumerator`	`sdkOnly()`
`abstract 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?
`abstract OrderRootsEnumerator`	`sources()`
`abstract OrderEnumerator`	`using(RootModelProvider provider)` Use `provider.getRootModel()` to process module dependencies
`abstract OrderEnumerator`	`withoutDepModules()`
`abstract OrderEnumerator`	`withoutLibraries()`
`abstract OrderEnumerator`	`withoutModuleSourceEntries()` Skip root module's entries
`abstract OrderEnumerator`	`withoutSdk()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - OrderEnumerator
```
public OrderEnumerator()
```
- Method Detail
  - productionOnly
```
public abstract OrderEnumerator productionOnly()
```
    Skip test dependencies
    
    Returns:
    
    this instance
  - compileOnly
```
public abstract OrderEnumerator compileOnly()
```
    Skip runtime-only dependencies
    
    Returns:
    
    this instance
  - runtimeOnly
```
public abstract OrderEnumerator runtimeOnly()
```
    Skip compile-only dependencies
    
    Returns:
    
    this instance
  - withoutSdk
```
public abstract OrderEnumerator withoutSdk()
```
  - withoutLibraries
```
public abstract OrderEnumerator withoutLibraries()
```
  - withoutDepModules
```
public abstract OrderEnumerator withoutDepModules()
```
  - withoutModuleSourceEntries
```
public abstract OrderEnumerator withoutModuleSourceEntries()
```
    Skip root module's entries
    
    Returns:
    
    this
  - librariesOnly
```
public OrderEnumerator librariesOnly()
```
  - sdkOnly
```
public OrderEnumerator sdkOnly()
```
  - getAllLibrariesAndSdkClassesRoots
```
public VirtualFile [] getAllLibrariesAndSdkClassesRoots()
```
  - getAllSourceRoots
```
public VirtualFile [] getAllSourceRoots()
```
  - recursively
```
public abstract OrderEnumerator recursively()
```
    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.
    
    Returns:
    
    this instance
  - exportedOnly
```
public abstract OrderEnumerator exportedOnly()
```
    Skip not exported dependencies. If this method is called after recursively() direct non-exported dependencies won't be skipped
    
    Returns:
    
    this instance
  - satisfying
```
public abstract OrderEnumerator satisfying(Condition<? super OrderEntry> condition)
```
    Process only entries which satisfies the specified condition
    
    Parameters:
    
    condition - filtering condition
    
    Returns:
    
    this instance
  - using
```
public abstract OrderEnumerator using(RootModelProvider provider)
```
    Use provider.getRootModel() to process module dependencies
    
    Parameters:
    
    provider - provider
    
    Returns:
    
    this instance
  - shouldRecurse
```
public abstract 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?
    
    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.
  - classes
```
public abstract OrderRootsEnumerator classes()
```
    Returns:
    
    OrderRootsEnumerator instance for processing classes roots
  - sources
```
public abstract OrderRootsEnumerator sources()
```
    Returns:
    
    OrderRootsEnumerator instance for processing source roots
  - roots
```
public abstract OrderRootsEnumerator roots(OrderRootType rootType)
```
    Parameters:
    
    rootType - root type
    
    Returns:
    
    OrderRootsEnumerator instance for processing roots of the specified type
  - roots
```
public abstract OrderRootsEnumerator roots(NotNullFunction<? super OrderEntry,? extends OrderRootType> rootTypeProvider)
```
    Parameters:
    
    rootTypeProvider - custom root type provider
    
    Returns:
    
    OrderRootsEnumerator instance for processing roots of the provided type
  - getClassesRoots
```
public VirtualFile [] getClassesRoots()
```
    Returns:
    
    classes roots for all entries processed by this enumerator
  - getSourceRoots
```
public VirtualFile [] getSourceRoots()
```
    Returns:
    
    source roots for all entries processed by this enumerator
  - getPathsList
```
public PathsList getPathsList()
```
    Returns:
    
    list containing classes roots for all entries processed by this enumerator
  - getSourcePathsList
```
public PathsList getSourcePathsList()
```
    Returns:
    
    list containing source roots for all entries processed by this enumerator
  - forEach
```
public abstract void forEach(Processor<? super OrderEntry> processor)
```
    Runs processor.process() for each entry processed by this enumerator.
    
    Parameters:
    
    processor - processor
  - forEachLibrary
```
public abstract void forEachLibrary(Processor<? super Library> processor)
```
    Runs processor.process() for each library processed by this enumerator.
    
    Parameters:
    
    processor - processor
  - forEachModule
```
public abstract void forEachModule(Processor<? super Module> processor)
```
    Runs processor.process() for each module processed by this enumerator.
    
    Parameters:
    
    processor - processor
  - process
```
public abstract <R> R process(RootPolicy<R> policy,
                              R initialValue)
```
    Passes order entries to the specified visitor.
    
    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)
  - orderEntries
```
public static OrderEnumerator orderEntries(Module module)
```
    Creates new enumerator instance to process dependencies of module
    
    Parameters:
    
    module - module
    
    Returns:
    
    new enumerator instance
  - orderEntries
```
public static OrderEnumerator orderEntries(Project project)
```
    Creates new enumerator instance to process dependencies of all modules in project. Only first level dependencies of modules are processed so recursively() option is ignored and withoutDepModules() option is forced
    
    Parameters:
    
    project - project
    
    Returns:
    
    new enumerator instance

Class OrderEnumerator

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

OrderEnumerator

Method Detail

productionOnly

compileOnly

runtimeOnly

withoutSdk

withoutLibraries

withoutDepModules

withoutModuleSourceEntries

librariesOnly

sdkOnly

getAllLibrariesAndSdkClassesRoots

getAllSourceRoots

recursively

exportedOnly

satisfying

using

shouldRecurse

classes

sources

roots

roots

getClassesRoots

getSourceRoots

getPathsList

getSourcePathsList

forEach

forEachLibrary

forEachModule

process

orderEntries

orderEntries