IG: use ThreeState enum instead of inventing own
[idea/community.git] / platform / projectModel-api / src / com / intellij / openapi / module / ModuleGrouper.kt
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.module
17
18 import com.intellij.openapi.project.Project
19 import com.intellij.openapi.util.registry.Registry
20 import org.jetbrains.annotations.ApiStatus
21
22 /**
23  * Use this class to determine how modules show by organized in a tree. It supports the both ways of module grouping: the old one where
24  * groups are specified explicitly and the new one where modules are grouped accordingly to their qualified names.
25  */
26 @ApiStatus.Experimental
27 abstract class ModuleGrouper {
28   /**
29    * Returns names of parent groups for a module
30    */
31   abstract fun getGroupPath(module: Module): List<String>
32
33   /**
34    * Returns names of parent groups for a module
35    */
36   abstract fun getGroupPath(description: ModuleDescription): List<String>
37
38   /**
39    * Returns name which should be used for a module when it's shown under its group
40    */
41   abstract fun getShortenedName(module: Module): String
42
43   /**
44    * Returns name which should be used for a module when it's shown under its ancestor group which qualified name is [parentGroupName].
45    * If [parentGroupName] is `null` returns the full module name.
46    */
47   abstract fun getShortenedName(module: Module, parentGroupName: String?): String
48
49   /**
50    * Returns name which should be used for a module with name [name] when it's shown under its group
51    */
52   abstract fun getShortenedNameByFullModuleName(name: String): String
53
54   /**
55    * Returns name which should be used for a module with name [name] when it's shown under its ancestor group which qualified name is [parentGroupName].
56    * If [parentGroupName] is `null` returns the full module name.
57    */
58   abstract fun getShortenedNameByFullModuleName(name: String, parentGroupName: String?): String
59
60   abstract fun getGroupPathByModuleName(name: String): List<String>
61
62   /**
63    * If [module] itself can be considered as a group, returns its groups. Otherwise returns null.
64    */
65   abstract fun getModuleAsGroupPath(module: Module): List<String>?
66
67   /**
68    * If [description] itself can be considered as a group, returns its groups. Otherwise returns null.
69    */
70   abstract fun getModuleAsGroupPath(description: ModuleDescription): List<String>?
71
72   abstract fun getAllModules(): Array<Module>
73
74   /**
75    * Determines whether module group nodes containing single child should be joined with the child nodes. E.g. the modules `foo.bar.baz`
76    * and `foo.bar.baz2` will form the following tree if [compactGroupNodes] is `false`
77    * ```
78    * foo
79    *  bar
80    *   baz
81    *   baz2
82    * ```
83    * and the following tree if [compactGroupNodes] is `true`:
84    * ```
85    * foo.bar
86    *  baz
87    *  baz2
88    * ```
89    */
90   abstract val compactGroupNodes: Boolean
91
92   companion object {
93     @JvmStatic
94     @JvmOverloads
95     fun instanceFor(project: Project, moduleModel: ModifiableModuleModel? = null): ModuleGrouper {
96       return ModuleManager.getInstance(project).getModuleGrouper(moduleModel)
97     }
98   }
99 }
100
101 fun isQualifiedModuleNamesEnabled(project: Project): Boolean = Registry.`is`("project.qualified.module.names") &&
102                                                                !ModuleManager.getInstance(project).hasModuleGroups()