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
156
157
158
|
/*
* Copyright 2000-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.facet.impl;
import com.intellij.facet.*;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.util.ModificationTracker;
import com.intellij.openapi.util.Disposer;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.Disposable;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.module.ModuleManager;
import com.intellij.openapi.module.Module;
import com.intellij.psi.util.CachedValueProvider;
import com.intellij.psi.util.CachedValuesManager;
import com.intellij.psi.util.CachedValue;
import com.intellij.util.SmartList;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.NotNull;
import java.util.*;
/**
* @author nik
*/
public class FacetFinderImpl extends FacetFinder {
private static final Logger LOG = Logger.getInstance("#com.intellij.facet.impl.FacetFinderImpl");
private final Map<FacetTypeId, AllFacetsOfTypeModificationTracker> myAllFacetTrackers = new HashMap<FacetTypeId, AllFacetsOfTypeModificationTracker>();
private final Map<FacetTypeId, CachedValue<Map<VirtualFile, List<Facet>>>> myCachedMaps =
new HashMap<FacetTypeId, CachedValue<Map<VirtualFile, List<Facet>>>>();
private final Project myProject;
private final CachedValuesManager myCachedValuesManager;
private final ModuleManager myModuleManager;
public FacetFinderImpl(Project project) {
myProject = project;
myCachedValuesManager = CachedValuesManager.getManager(project);
myModuleManager = ModuleManager.getInstance(myProject);
}
@Override
public <F extends Facet> ModificationTracker getAllFacetsOfTypeModificationTracker(FacetTypeId<F> type) {
AllFacetsOfTypeModificationTracker tracker = myAllFacetTrackers.get(type);
if (tracker == null) {
tracker = new AllFacetsOfTypeModificationTracker<F>(myProject, type);
Disposer.register(myProject, tracker);
myAllFacetTrackers.put(type, tracker);
}
return tracker;
}
private <F extends Facet & FacetRootsProvider> Map<VirtualFile, List<Facet>> getRootToFacetsMap(final FacetTypeId<F> type) {
CachedValue<Map<VirtualFile, List<Facet>>> cachedValue = myCachedMaps.get(type);
if (cachedValue == null) {
cachedValue = myCachedValuesManager.createCachedValue(new CachedValueProvider<Map<VirtualFile, List<Facet>>>() {
@Override
public Result<Map<VirtualFile, List<Facet>>> compute() {
Map<VirtualFile, List<Facet>> map = computeRootToFacetsMap(type);
return Result.create(map, getAllFacetsOfTypeModificationTracker(type));
}
}, false);
myCachedMaps.put(type, cachedValue);
}
final Map<VirtualFile, List<Facet>> value = cachedValue.getValue();
LOG.assertTrue(value != null);
return value;
}
@NotNull
private <F extends Facet&FacetRootsProvider> Map<VirtualFile, List<Facet>> computeRootToFacetsMap(final FacetTypeId<F> type) {
final Module[] modules = myModuleManager.getModules();
final HashMap<VirtualFile, List<Facet>> map = new HashMap<VirtualFile, List<Facet>>();
for (Module module : modules) {
final Collection<F> facets = FacetManager.getInstance(module).getFacetsByType(type);
for (F facet : facets) {
for (VirtualFile root : facet.getFacetRoots()) {
List<Facet> list = map.get(root);
if (list == null) {
list = new SmartList<Facet>();
map.put(root, list);
}
list.add(facet);
}
}
}
return map;
}
@Override
@Nullable
public <F extends Facet & FacetRootsProvider> F findFacet(VirtualFile file, FacetTypeId<F> type) {
final List<F> list = findFacets(file, type);
return list.size() > 0 ? list.get(0) : null;
}
@Override
@NotNull
public <F extends Facet & FacetRootsProvider> List<F> findFacets(VirtualFile file, FacetTypeId<F> type) {
final Map<VirtualFile, List<Facet>> map = getRootToFacetsMap(type);
if (!map.isEmpty()) {
while (file != null) {
final List<F> list = (List<F>)((List)map.get(file));
if (list != null) {
return list;
}
file = file.getParent();
}
}
return Collections.<F>emptyList();
}
private static class AllFacetsOfTypeModificationTracker<F extends Facet> extends ProjectWideFacetAdapter<F>
implements ModificationTracker, Disposable {
private long myModificationCount;
public AllFacetsOfTypeModificationTracker(final Project project, final FacetTypeId<F> type) {
ProjectWideFacetListenersRegistry.getInstance(project).registerListener(type, this, this);
}
@Override
public void facetAdded(final F facet) {
myModificationCount++;
}
@Override
public void facetRemoved(final F facet) {
myModificationCount++;
}
@Override
public void facetConfigurationChanged(final F facet) {
myModificationCount++;
}
@Override
public void dispose() {
}
@Override
public long getModificationCount() {
return myModificationCount;
}
}
}
|
