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
|
/*
* Copyright 2000-2014 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.psi.search.searches;
import com.intellij.openapi.extensions.ExtensionPointName;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiReference;
import com.intellij.psi.search.*;
import com.intellij.util.*;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
* @author max
*/
public class ReferencesSearch extends ExtensibleQueryFactory<PsiReference, ReferencesSearch.SearchParameters> {
public static ExtensionPointName<QueryExecutor> EP_NAME = ExtensionPointName.create("com.intellij.referencesSearch");
private static final ReferencesSearch INSTANCE = new ReferencesSearch();
private ReferencesSearch() {
}
public static class SearchParameters {
private final PsiElement myElementToSearch;
private final SearchScope myScope;
private final boolean myIgnoreAccessScope;
private final SearchRequestCollector myOptimizer;
private final boolean isSharedOptimizer;
public SearchParameters(@NotNull PsiElement elementToSearch, @NotNull SearchScope scope, boolean ignoreAccessScope, @Nullable SearchRequestCollector optimizer) {
myElementToSearch = elementToSearch;
myScope = scope;
myIgnoreAccessScope = ignoreAccessScope;
isSharedOptimizer = optimizer != null;
myOptimizer = optimizer == null ? new SearchRequestCollector(new SearchSession()) : optimizer;
}
public SearchParameters(@NotNull PsiElement elementToSearch, @NotNull SearchScope scope, final boolean ignoreAccessScope) {
this(elementToSearch, scope, ignoreAccessScope, null);
}
@NotNull
public PsiElement getElementToSearch() {
return myElementToSearch;
}
/**
* Use {@link #getEffectiveSearchScope} instead
*/
@Deprecated()
@NotNull
public SearchScope getScope() {
return myScope;
}
public boolean isIgnoreAccessScope() {
return myIgnoreAccessScope;
}
@NotNull
public SearchRequestCollector getOptimizer() {
return myOptimizer;
}
@NotNull
public SearchScope getEffectiveSearchScope () {
if (myIgnoreAccessScope) {
return myScope;
}
SearchScope accessScope = PsiSearchHelper.SERVICE.getInstance(myElementToSearch.getProject()).getUseScope(myElementToSearch);
return myScope.intersectWith(accessScope);
}
}
@NotNull
public static Query<PsiReference> search(@NotNull PsiElement element) {
return search(element, GlobalSearchScope.allScope(element.getProject()), false);
}
@NotNull
public static Query<PsiReference> search(@NotNull PsiElement element, @NotNull SearchScope searchScope) {
return search(element, searchScope, false);
}
@NotNull
public static Query<PsiReference> search(@NotNull PsiElement element, @NotNull SearchScope searchScope, boolean ignoreAccessScope) {
return search(new SearchParameters(element, searchScope, ignoreAccessScope));
}
@NotNull
public static Query<PsiReference> search(@NotNull final SearchParameters parameters) {
final Query<PsiReference> result = INSTANCE.createQuery(parameters);
if (parameters.isSharedOptimizer) {
return uniqueResults(result);
}
final SearchRequestCollector requests = parameters.getOptimizer();
final PsiElement element = parameters.getElementToSearch();
return uniqueResults(new MergeQuery<PsiReference>(result, new SearchRequestQuery(element.getProject(), requests)));
}
@NotNull
private static UniqueResultsQuery<PsiReference, ReferenceDescriptor> uniqueResults(@NotNull Query<PsiReference> composite) {
return new UniqueResultsQuery<PsiReference, ReferenceDescriptor>(composite, ContainerUtil.<ReferenceDescriptor>canonicalStrategy(), ReferenceDescriptor.MAPPER);
}
public static void searchOptimized(@NotNull PsiElement element,
@NotNull SearchScope searchScope,
boolean ignoreAccessScope,
@NotNull SearchRequestCollector collector,
@NotNull final Processor<PsiReference> processor) {
searchOptimized(element, searchScope, ignoreAccessScope, collector, false, new PairProcessor<PsiReference, SearchRequestCollector>() {
@Override
public boolean process(PsiReference psiReference, SearchRequestCollector collector) {
return processor.process(psiReference);
}
});
}
public static void searchOptimized(@NotNull PsiElement element,
@NotNull SearchScope searchScope,
boolean ignoreAccessScope,
@NotNull SearchRequestCollector collector,
final boolean inReadAction,
@NotNull PairProcessor<PsiReference, SearchRequestCollector> processor) {
final SearchRequestCollector nested = new SearchRequestCollector(collector.getSearchSession());
Query<PsiReference> query = search(new SearchParameters(element, searchScope, ignoreAccessScope, nested));
collector.searchQuery(new QuerySearchRequest(query, nested, inReadAction, processor));
}
}
|
