OLD | NEW |
| (Empty) |
1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file | |
2 // for details. All rights reserved. Use of this source code is governed by a | |
3 // BSD-style license that can be found in the LICENSE file. | |
4 | |
5 // This code was auto-generated, is not intended to be edited, and is subject to | |
6 // significant change. Please see the README file for more information. | |
7 | |
8 library services.status; | |
9 | |
10 import 'package:analyzer/src/generated/java_core.dart'; | |
11 import 'package:analyzer/src/generated/ast.dart'; | |
12 import 'package:analyzer/src/generated/element.dart'; | |
13 import 'package:analyzer/src/generated/engine.dart'; | |
14 import 'package:analyzer/src/generated/source.dart'; | |
15 import 'stubs.dart'; | |
16 | |
17 /** | |
18 * Outcome of a condition checking operation. | |
19 */ | |
20 class RefactoringStatus { | |
21 /** | |
22 * @return the new [RefactoringStatus] with [RefactoringStatusSeverity#ERROR]. | |
23 */ | |
24 static RefactoringStatus createErrorStatus(String msg) { | |
25 RefactoringStatus status = new RefactoringStatus(); | |
26 status.addError(msg); | |
27 return status; | |
28 } | |
29 | |
30 /** | |
31 * @return the new [RefactoringStatus] with [RefactoringStatusSeverity#FATAL]. | |
32 */ | |
33 static RefactoringStatus createFatalErrorStatus(String msg, [RefactoringStatus
Context context]) { | |
34 RefactoringStatus status = new RefactoringStatus(); | |
35 status.addFatalError(msg, context); | |
36 return status; | |
37 } | |
38 | |
39 /** | |
40 * @return the new [RefactoringStatus] with [RefactoringStatusSeverity#WARNING
]. | |
41 */ | |
42 static RefactoringStatus createWarningStatus(String msg) { | |
43 RefactoringStatus status = new RefactoringStatus(); | |
44 status.addWarning(msg); | |
45 return status; | |
46 } | |
47 | |
48 /** | |
49 * @return the [Enum] value with maximal ordinal. | |
50 */ | |
51 static Enum _max(Enum a, Enum b) { | |
52 if (b.ordinal > a.ordinal) { | |
53 return b; | |
54 } | |
55 return a; | |
56 } | |
57 | |
58 RefactoringStatusSeverity _severity = RefactoringStatusSeverity.OK; | |
59 | |
60 final List<RefactoringStatusEntry> entries = []; | |
61 | |
62 /** | |
63 * Adds a <code>ERROR</code> entry filled with the given message and status to
this status. | |
64 */ | |
65 void addError(String msg, [RefactoringStatusContext context]) { | |
66 _addEntry(new RefactoringStatusEntry(RefactoringStatusSeverity.ERROR, msg, c
ontext)); | |
67 } | |
68 | |
69 /** | |
70 * Adds a <code>FATAL</code> entry filled with the given message and status to
this status. | |
71 */ | |
72 void addFatalError(String msg, [RefactoringStatusContext context]) { | |
73 _addEntry(new RefactoringStatusEntry(RefactoringStatusSeverity.FATAL, msg, c
ontext)); | |
74 } | |
75 | |
76 /** | |
77 * Adds a <code>WARNING</code> entry filled with the given message and status
to this status. | |
78 */ | |
79 void addWarning(String msg, [RefactoringStatusContext context]) { | |
80 _addEntry(new RefactoringStatusEntry(RefactoringStatusSeverity.WARNING, msg,
context)); | |
81 } | |
82 | |
83 /** | |
84 * @return the copy of this [RefactoringStatus] with [RefactoringStatusSeverit
y#ERROR] | |
85 * replaced with [RefactoringStatusSeverity#FATAL]. | |
86 */ | |
87 RefactoringStatus escalateErrorToFatal() { | |
88 RefactoringStatus result = new RefactoringStatus(); | |
89 for (RefactoringStatusEntry entry in entries) { | |
90 RefactoringStatusSeverity severity = entry.severity; | |
91 if (severity == RefactoringStatusSeverity.ERROR) { | |
92 severity = RefactoringStatusSeverity.FATAL; | |
93 } | |
94 result._addEntry(new RefactoringStatusEntry(severity, entry.message, entry
.context)); | |
95 } | |
96 return result; | |
97 } | |
98 | |
99 /** | |
100 * @return the RefactoringStatusEntry with the highest severity, or <code>null
</code> if no | |
101 * entries are present. | |
102 */ | |
103 RefactoringStatusEntry get entryWithHighestSeverity { | |
104 if (entries.isEmpty) { | |
105 return null; | |
106 } | |
107 RefactoringStatusEntry result = entries[0]; | |
108 for (RefactoringStatusEntry entry in entries) { | |
109 if (result.severity.ordinal < entry.severity.ordinal) { | |
110 result = entry; | |
111 } | |
112 } | |
113 return result; | |
114 } | |
115 | |
116 /** | |
117 * @return the message from the [RefactoringStatusEntry] with highest severity
; may be | |
118 * <code>null</code> if not entries are present. | |
119 */ | |
120 String get message { | |
121 RefactoringStatusEntry entry = entryWithHighestSeverity; | |
122 if (entry == null) { | |
123 return null; | |
124 } | |
125 return entry.message; | |
126 } | |
127 | |
128 /** | |
129 * @return the current severity of the [RefactoringStatus]. | |
130 */ | |
131 RefactoringStatusSeverity get severity => _severity; | |
132 | |
133 /** | |
134 * @return <code>true</code> if the current severity is <code> | |
135 * FATAL</code> or <code>ERROR</code>. | |
136 */ | |
137 bool get hasError => _severity == RefactoringStatusSeverity.FATAL || _severity
== RefactoringStatusSeverity.ERROR; | |
138 | |
139 /** | |
140 * @return <code>true</code> if the current severity is <code>FATAL</code>. | |
141 */ | |
142 bool get hasFatalError => _severity == RefactoringStatusSeverity.FATAL; | |
143 | |
144 /** | |
145 * @return <code>true</code> if the current severity is <code> | |
146 * FATAL</code>, <code>ERROR</code>, <code>WARNING</code> or <code>INFO</code
>. | |
147 */ | |
148 bool get hasInfo => _severity == RefactoringStatusSeverity.FATAL || _severity
== RefactoringStatusSeverity.ERROR || _severity == RefactoringStatusSeverity.WAR
NING || _severity == RefactoringStatusSeverity.INFO; | |
149 | |
150 /** | |
151 * @return <code>true</code> if the current severity is <code> | |
152 * FATAL</code>, <code>ERROR</code> or <code>WARNING</code>. | |
153 */ | |
154 bool get hasWarning => _severity == RefactoringStatusSeverity.FATAL || _severi
ty == RefactoringStatusSeverity.ERROR || _severity == RefactoringStatusSeverity.
WARNING; | |
155 | |
156 /** | |
157 * @return <code>true</code> if the severity is <code>OK</code>. | |
158 */ | |
159 bool get isOK => _severity == RefactoringStatusSeverity.OK; | |
160 | |
161 /** | |
162 * Merges the receiver and the parameter statuses. The resulting list of entri
es in the receiver | |
163 * will contain entries from both. The resulting severity in the receiver will
be the more severe | |
164 * of its current severity and the parameter's severity. Merging with <code>nu
ll</code> is allowed | |
165 * - it has no effect. | |
166 */ | |
167 void merge(RefactoringStatus other) { | |
168 if (other == null) { | |
169 return; | |
170 } | |
171 entries.addAll(other.entries); | |
172 _severity = _max(_severity, other.severity); | |
173 } | |
174 | |
175 @override | |
176 String toString() { | |
177 JavaStringBuilder sb = new JavaStringBuilder(); | |
178 sb.append("<").append(_severity.name); | |
179 if (!isOK) { | |
180 sb.append("\n"); | |
181 for (RefactoringStatusEntry entry in entries) { | |
182 sb.append("\t").append(entry).append("\n"); | |
183 } | |
184 } | |
185 sb.append(">"); | |
186 return sb.toString(); | |
187 } | |
188 | |
189 /** | |
190 * Adds given [RefactoringStatusEntry] and updates [severity]. | |
191 */ | |
192 void _addEntry(RefactoringStatusEntry entry) { | |
193 entries.add(entry); | |
194 _severity = _max(_severity, entry.severity); | |
195 } | |
196 } | |
197 | |
198 /** | |
199 * [RefactoringStatusContext] can be used to annotate a [RefactoringStatusEntry]
with | |
200 * additional information typically presented in the user interface. | |
201 */ | |
202 class RefactoringStatusContext { | |
203 /** | |
204 * @return the [RefactoringStatusContext] that corresponds to the given [Searc
hMatch]. | |
205 */ | |
206 static RefactoringStatusContext create(SearchMatch match) { | |
207 Element enclosingElement = match.element; | |
208 return new RefactoringStatusContext(enclosingElement.context, enclosingEleme
nt.source, match.sourceRange); | |
209 } | |
210 | |
211 AnalysisContext _context; | |
212 | |
213 Source _source; | |
214 | |
215 SourceRange _range; | |
216 | |
217 RefactoringStatusContext(AnalysisContext context, Source source, SourceRange r
ange) { | |
218 this._context = context; | |
219 this._source = source; | |
220 this._range = range; | |
221 } | |
222 | |
223 /** | |
224 * Creates a new [RefactoringStatusContext] which corresponds to the given [As
tNode]. | |
225 */ | |
226 RefactoringStatusContext.forNode(AstNode node) { | |
227 CompilationUnit unit = node.getAncestor((node) => node is CompilationUnit); | |
228 CompilationUnitElement unitElement = unit.element; | |
229 this._context = unitElement.context; | |
230 this._source = unitElement.source; | |
231 this._range = SourceRangeFactory.rangeNode(node); | |
232 } | |
233 | |
234 /** | |
235 * Creates a new [RefactoringStatusContext] which corresponds to given locatio
n in the | |
236 * [Source] of the given [CompilationUnit]. | |
237 */ | |
238 RefactoringStatusContext.forUnit(CompilationUnit unit, SourceRange range) { | |
239 CompilationUnitElement unitElement = unit.element; | |
240 this._context = unitElement.context; | |
241 this._source = unitElement.source; | |
242 this._range = range; | |
243 } | |
244 | |
245 /** | |
246 * @return the [RefactoringStatusContext] which corresponds to the declaration
of the given | |
247 * [Element]. | |
248 */ | |
249 RefactoringStatusContext.forElement(Element element) { | |
250 this._context = element.context; | |
251 this._source = element.source; | |
252 this._range = SourceRangeFactory.rangeElementName(element); | |
253 } | |
254 | |
255 /** | |
256 * @return the [AnalysisContext] in which this status occurs. | |
257 */ | |
258 AnalysisContext get context => _context; | |
259 | |
260 /** | |
261 * @return the [SourceRange] with specific location where this status occurs. | |
262 */ | |
263 SourceRange get range => _range; | |
264 | |
265 /** | |
266 * @return the [Source] in which this status occurs. | |
267 */ | |
268 Source get source => _source; | |
269 | |
270 @override | |
271 String toString() { | |
272 JavaStringBuilder builder = new JavaStringBuilder(); | |
273 builder.append("[source="); | |
274 builder.append(_source); | |
275 builder.append(", range="); | |
276 builder.append(_range); | |
277 builder.append("]"); | |
278 return builder.toString(); | |
279 } | |
280 } | |
281 | |
282 /** | |
283 * An immutable object representing an entry in the list in [RefactoringStatus].
A refactoring | |
284 * status entry consists of a severity, a message and a context object. | |
285 */ | |
286 class RefactoringStatusEntry { | |
287 /** | |
288 * The severity level. | |
289 */ | |
290 final RefactoringStatusSeverity severity; | |
291 | |
292 /** | |
293 * The message of the status entry. | |
294 */ | |
295 final String message; | |
296 | |
297 /** | |
298 * The [RefactoringStatusContext] which can be used to show more detailed info
rmation | |
299 * regarding this status entry in the UI. May be `null` indicating that no con
text is | |
300 * available. | |
301 */ | |
302 RefactoringStatusContext _context; | |
303 | |
304 RefactoringStatusEntry(this.severity, this.message, [RefactoringStatusContext
ctx]) { | |
305 this._context = ctx; | |
306 } | |
307 | |
308 /** | |
309 * @return the [RefactoringStatusContext] which can be used to show more detai
led | |
310 * information regarding this status entry in the UI. The method may r
eturn `null` | |
311 * indicating that no context is available. | |
312 */ | |
313 RefactoringStatusContext get context => _context; | |
314 | |
315 /** | |
316 * Returns whether the entry represents an error or not. | |
317 * | |
318 * @return <code>true</code> if (severity ==<code>RefactoringStatusSeverity.ER
ROR</code>). | |
319 */ | |
320 bool get isError => severity == RefactoringStatusSeverity.ERROR; | |
321 | |
322 /** | |
323 * Returns whether the entry represents a fatal error or not. | |
324 * | |
325 * @return <code>true</code> if (severity ==<code>RefactoringStatusSeverity.FA
TAL</code>) | |
326 */ | |
327 bool get isFatalError => severity == RefactoringStatusSeverity.FATAL; | |
328 | |
329 /** | |
330 * Returns whether the entry represents an information or not. | |
331 * | |
332 * @return <code>true</code> if (severity ==<code>RefactoringStatusSeverity.IN
FO</code>). | |
333 */ | |
334 bool get isInfo => severity == RefactoringStatusSeverity.INFO; | |
335 | |
336 /** | |
337 * Returns whether the entry represents a warning or not. | |
338 * | |
339 * @return <code>true</code> if (severity ==<code>RefactoringStatusSeverity.WA
RNING</code>). | |
340 */ | |
341 bool get isWarning => severity == RefactoringStatusSeverity.WARNING; | |
342 | |
343 @override | |
344 String toString() { | |
345 if (_context != null) { | |
346 return "${severity}: ${message}; Context: ${_context}"; | |
347 } else { | |
348 return "${severity}: ${message}"; | |
349 } | |
350 } | |
351 } | |
352 | |
353 /** | |
354 * Severity of [RefactoringStatus]. | |
355 */ | |
356 class RefactoringStatusSeverity extends Enum<RefactoringStatusSeverity> { | |
357 static const RefactoringStatusSeverity OK = const RefactoringStatusSeverity('O
K', 0); | |
358 | |
359 static const RefactoringStatusSeverity INFO = const RefactoringStatusSeverity(
'INFO', 1); | |
360 | |
361 static const RefactoringStatusSeverity WARNING = const RefactoringStatusSeveri
ty('WARNING', 2); | |
362 | |
363 static const RefactoringStatusSeverity ERROR = const RefactoringStatusSeverity
('ERROR', 3); | |
364 | |
365 static const RefactoringStatusSeverity FATAL = const RefactoringStatusSeverity
('FATAL', 4); | |
366 | |
367 static const List<RefactoringStatusSeverity> values = const [OK, INFO, WARNING
, ERROR, FATAL]; | |
368 | |
369 const RefactoringStatusSeverity(String name, int ordinal) : super(name, ordina
l); | |
370 } | |
OLD | NEW |