1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.workspaceModel.ide.impl.legacyBridge.module.roots
import com.intellij.openapi.Disposable
import com.intellij.openapi.extensions.ExtensionPointListener
import com.intellij.openapi.extensions.PluginDescriptor
import com.intellij.openapi.module.Module
import com.intellij.openapi.projectRoots.Sdk
import com.intellij.openapi.roots.*
import com.intellij.openapi.roots.impl.ModuleOrderEnumerator
import com.intellij.openapi.roots.impl.RootConfigurationAccessor
import com.intellij.openapi.util.Disposer
import com.intellij.openapi.vfs.VirtualFile
import com.intellij.workspaceModel.ide.impl.legacyBridge.RootConfigurationAccessorForWorkspaceModel
import com.intellij.workspaceModel.ide.impl.legacyBridge.module.ModuleManagerBridgeImpl.Companion.findModuleEntity
import com.intellij.workspaceModel.ide.legacyBridge.ModuleBridge
import com.intellij.workspaceModel.storage.CachedValue
import com.intellij.workspaceModel.storage.WorkspaceEntityStorage
import com.intellij.workspaceModel.storage.WorkspaceEntityStorageBuilder
import com.intellij.workspaceModel.storage.impl.DisposableCachedValue
import com.intellij.workspaceModel.storage.url.VirtualFileUrl
import org.jetbrains.jps.model.module.JpsModuleSourceRoot
import org.jetbrains.jps.model.module.JpsModuleSourceRootType
class ModuleRootComponentBridge(
private val currentModule: Module
) : ModuleRootManagerEx(), Disposable, ModuleRootModelBridge {
override val moduleBridge = currentModule as ModuleBridge
private val orderRootsCache = OrderRootsCacheBridge(currentModule.project, currentModule)
private val modelValue = DisposableCachedValue(
{ moduleBridge.entityStorage },
CachedValue { storage ->
RootModelBridgeImpl(
moduleEntity = storage.findModuleEntity(moduleBridge),
storage = moduleBridge.entityStorage,
itemUpdater = null,
// TODO
rootModel = this,
updater = null
)
}).also { Disposer.register(this, it) }
internal val moduleLibraryTable: ModuleLibraryTableBridgeImpl = ModuleLibraryTableBridgeImpl(moduleBridge)
fun getModuleLibraryTable(): ModuleLibraryTableBridge {
return moduleLibraryTable
}
init {
MODULE_EXTENSION_NAME.getPoint(moduleBridge).addExtensionPointListener(object : ExtensionPointListener<ModuleExtension?> {
override fun extensionAdded(extension: ModuleExtension, pluginDescriptor: PluginDescriptor) {
dropRootModelCache()
}
override fun extensionRemoved(extension: ModuleExtension, pluginDescriptor: PluginDescriptor) {
dropRootModelCache()
}
}, false, null)
}
private val model: RootModelBridgeImpl
get() = modelValue.value
override val storage: WorkspaceEntityStorage
get() = moduleBridge.entityStorage.current
override val accessor: RootConfigurationAccessor
get() = RootConfigurationAccessor.DEFAULT_INSTANCE
override fun getOrCreateJpsRootProperties(sourceRootUrl: VirtualFileUrl, creator: () -> JpsModuleSourceRoot): JpsModuleSourceRoot {
return creator()
}
override fun removeCachedJpsRootProperties(sourceRootUrl: VirtualFileUrl) {
}
override fun dispose() = Unit
override fun dropCaches() {
orderRootsCache.clearCache()
dropRootModelCache()
}
internal fun dropRootModelCache() {
modelValue.dropCache()
}
override fun getModificationCountForTests(): Long = moduleBridge.entityStorage.version
override fun getExternalSource(): ProjectModelExternalSource? =
ExternalProjectSystemRegistry.getInstance().getExternalSource(module)
override fun getFileIndex(): ModuleFileIndex = currentModule.getService(ModuleFileIndex::class.java)!!
override fun getModifiableModel(): ModifiableRootModel = getModifiableModel(RootConfigurationAccessor.DEFAULT_INSTANCE)
override fun getModifiableModel(accessor: RootConfigurationAccessor): ModifiableRootModel = ModifiableRootModelBridgeImpl(
WorkspaceEntityStorageBuilder.from(moduleBridge.entityStorage.current),
moduleBridge,
accessor)
/**
* This method is used in Project Structure dialog to ensure that changes made in {@link ModifiableModuleModel} after creation
* of this {@link ModifiableRootModel} are available in its storage and references in its {@link OrderEntry} can be resolved properly.
*/
override fun getModifiableModelForMultiCommit(accessor: RootConfigurationAccessor): ModifiableRootModel = ModifiableRootModelBridgeImpl(
(moduleBridge.diff as? WorkspaceEntityStorageBuilder) ?: (accessor as? RootConfigurationAccessorForWorkspaceModel)?.actualDiffBuilder
?: WorkspaceEntityStorageBuilder.from(moduleBridge.entityStorage.current),
moduleBridge,
accessor)
fun getModifiableModel(diff: WorkspaceEntityStorageBuilder, accessor: RootConfigurationAccessor): ModifiableRootModel {
return ModifiableRootModelBridgeImpl(diff, moduleBridge, accessor, false)
}
override fun getDependencies(): Array<Module> = moduleDependencies
override fun getDependencies(includeTests: Boolean): Array<Module> = getModuleDependencies(includeTests = includeTests)
override fun isDependsOn(module: Module): Boolean = orderEntries.any { it is ModuleOrderEntry && it.module == module }
override fun getExcludeRoots(): Array<VirtualFile> = model.excludeRoots
override fun orderEntries(): OrderEnumerator = ModuleOrderEnumerator(this, orderRootsCache)
override fun <T : Any?> getModuleExtension(klass: Class<T>): T? {
return model.getModuleExtension(klass)
}
override fun getDependencyModuleNames(): Array<String> = model.dependencyModuleNames
override fun getModule(): Module = currentModule
override fun isSdkInherited(): Boolean = model.isSdkInherited
override fun getOrderEntries(): Array<OrderEntry> = model.orderEntries
override fun getSourceRootUrls(): Array<String> = model.sourceRootUrls
override fun getSourceRootUrls(includingTests: Boolean): Array<String> = model.getSourceRootUrls(includingTests)
override fun getContentEntries(): Array<ContentEntry> = model.contentEntries
override fun getExcludeRootUrls(): Array<String> = model.excludeRootUrls
override fun <R : Any?> processOrder(policy: RootPolicy<R>, initialValue: R): R = model.processOrder(policy, initialValue)
override fun getSdk(): Sdk? = model.sdk
override fun getSourceRoots(): Array<VirtualFile> = model.sourceRoots
override fun getSourceRoots(includingTests: Boolean): Array<VirtualFile> = model.getSourceRoots(includingTests)
override fun getSourceRoots(rootType: JpsModuleSourceRootType<*>): MutableList<VirtualFile> = model.getSourceRoots(rootType)
override fun getSourceRoots(rootTypes: MutableSet<out JpsModuleSourceRootType<*>>): MutableList<VirtualFile> = model.getSourceRoots(
rootTypes)
override fun getContentRoots(): Array<VirtualFile> = model.contentRoots
override fun getContentRootUrls(): Array<String> = model.contentRootUrls
override fun getModuleDependencies(): Array<Module> = model.moduleDependencies
override fun getModuleDependencies(includeTests: Boolean): Array<Module> = model.getModuleDependencies(includeTests)
companion object {
@JvmStatic
fun getInstance(module: Module): ModuleRootComponentBridge = ModuleRootManager.getInstance(module) as ModuleRootComponentBridge
}
}
|
