1 /*******************************************************************************
2  * Copyright (c) 2008, 2019 IBM Corporation and others.
3  *
4  * This program and the accompanying materials
5  * are made available under the terms of the Eclipse Public License 2.0
6  * which accompanies this distribution, and is available at
7  * https://www.eclipse.org/legal/epl-2.0/
8  *
9  * SPDX-License-Identifier: EPL-2.0
10  *
11  * Contributors:
12  *     IBM Corporation - initial API and implementation
13  *******************************************************************************/
14 package org.eclipse.pde.api.tools.internal.comparator;
15 
16 import java.text.MessageFormat;
17 import java.util.Enumeration;
18 import java.util.Hashtable;
19 import java.util.Locale;
20 import java.util.MissingResourceException;
21 import java.util.ResourceBundle;
22 
23 import org.eclipse.jdt.core.Flags;
24 import org.eclipse.osgi.util.NLS;
25 import org.eclipse.pde.api.tools.internal.provisional.RestrictionModifiers;
26 import org.eclipse.pde.api.tools.internal.provisional.comparator.IDelta;
27 
28 /**
29  * Class that manages the messages for compatible deltas.
30  */
31 public class Messages extends NLS {
32 	/**
33 	 * The current mapping of problem id to message
34 	 */
35 	private static Hashtable<Integer, String> fMessages = null;
36 
37 	public static String problem_message_not_found;
38 
39 	static {
40 		// initialize resource bundle
41 		NLS.initializeMessages("org.eclipse.pde.api.tools.internal.comparator.messages", Messages.class); //$NON-NLS-1$
42 	}
43 
Messages()44 	private Messages() {
45 	}
46 
47 	/**
48 	 * This method initializes the MessageTemplates class variable according to
49 	 * the current Locale.
50 	 *
51 	 * @param loc Locale
52 	 * @return HashtableOfInt
53 	 */
loadMessageTemplates(Locale loc)54 	public static Hashtable<Integer, String> loadMessageTemplates(Locale loc) {
55 		ResourceBundle bundle = null;
56 		String bundleName = "org.eclipse.pde.api.tools.internal.comparator.compatible_delta_messages"; //$NON-NLS-1$
57 		try {
58 			bundle = ResourceBundle.getBundle(bundleName, loc);
59 		} catch (MissingResourceException e) {
60 			System.out.println("Missing resource : " + bundleName.replace('.', '/') + ".properties for locale " + loc); //$NON-NLS-1$//$NON-NLS-2$
61 			throw e;
62 		}
63 		Hashtable<Integer, String> templates = new Hashtable<>(700);
64 		Enumeration<String> keys = bundle.getKeys();
65 		while (keys.hasMoreElements()) {
66 			String key = keys.nextElement();
67 			try {
68 				int messageID = Integer.parseInt(key);
69 				templates.put(Integer.valueOf(messageID), bundle.getString(key));
70 			} catch (NumberFormatException | MissingResourceException e) {
71 				// available ID
72 			}
73 		}
74 		return templates;
75 	}
76 
getCompatibleLocalizedMessage(Delta delta)77 	public static String getCompatibleLocalizedMessage(Delta delta) {
78 		if (fMessages == null) {
79 			fMessages = loadMessageTemplates(Locale.getDefault());
80 		}
81 		Integer key = Integer.valueOf(getKey(delta));
82 		String message = fMessages.get(key);
83 		if (message == null) {
84 			return MessageFormat.format(Messages.problem_message_not_found, String.valueOf(key));
85 		}
86 		String[] arguments = delta.getArguments();
87 		if (arguments != null) {
88 			// for expanded and contracted superset
89 			if (arguments.length == 2) {
90 				return MessageFormat.format(message, (Object[]) arguments);
91 			}
92 		}
93 		if (arguments.length != 0) {
94 			return MessageFormat.format(message, (Object[]) arguments);
95 		}
96 		return message;
97 	}
98 
getKey(IDelta delta)99 	private static int getKey(IDelta delta) {
100 		switch (delta.getElementType()) {
101 			case IDelta.ANNOTATION_ELEMENT_TYPE:
102 				switch (delta.getKind()) {
103 					case IDelta.ADDED:
104 						switch (delta.getFlags()) {
105 							case IDelta.METHOD_WITH_DEFAULT_VALUE:
106 								return 1;
107 							case IDelta.DEPRECATION:
108 								return 110;
109 							default:
110 								break;
111 						}
112 						break;
113 					case IDelta.CHANGED:
114 						switch (delta.getFlags()) {
115 							case IDelta.DECREASE_ACCESS:
116 								return 101;
117 							default:
118 								break;
119 						}
120 						break;
121 					case IDelta.REMOVED:
122 						switch (delta.getFlags()) {
123 							case IDelta.DEPRECATION:
124 								return 111;
125 							default:
126 								break;
127 						}
128 						break;
129 					default:
130 						break;
131 				}
132 				break;
133 			case IDelta.API_COMPONENT_ELEMENT_TYPE:
134 				switch (delta.getKind()) {
135 					case IDelta.ADDED:
136 						switch (delta.getFlags()) {
137 							case IDelta.EXECUTION_ENVIRONMENT:
138 								return 2;
139 							case IDelta.TYPE:
140 								return 3;
141 							case IDelta.REEXPORTED_TYPE:
142 								return 109;
143 							default:
144 								break;
145 						}
146 						break;
147 					case IDelta.CHANGED:
148 						switch (delta.getFlags()) {
149 							case IDelta.TYPE_VISIBILITY:
150 								return 4;
151 							case IDelta.MAJOR_VERSION:
152 								return 95;
153 							case IDelta.MINOR_VERSION:
154 								return 96;
155 							default:
156 								break;
157 						}
158 						break;
159 					case IDelta.REMOVED:
160 						if (delta.getFlags() == IDelta.EXECUTION_ENVIRONMENT) {
161 							return 5;
162 						}
163 						break;
164 					default:
165 						break;
166 				}
167 				break;
168 			case IDelta.API_BASELINE_ELEMENT_TYPE:
169 				switch (delta.getKind()) {
170 					case IDelta.ADDED:
171 						if (delta.getFlags() == IDelta.API_COMPONENT) {
172 							return 6;
173 						}
174 						break;
175 					default:
176 						break;
177 				}
178 				break;
179 			case IDelta.CLASS_ELEMENT_TYPE:
180 				switch (delta.getKind()) {
181 					case IDelta.ADDED:
182 						switch (delta.getFlags()) {
183 							case IDelta.DEPRECATION:
184 								return 110;
185 							case IDelta.CLINIT:
186 								return 7;
187 							case IDelta.CONSTRUCTOR:
188 								return 8;
189 							case IDelta.FIELD:
190 								if (Flags.isProtected(delta.getNewModifiers())) {
191 									return 9;
192 								}
193 								if (Flags.isStatic(delta.getNewModifiers())) {
194 									return 10;
195 								}
196 								if (Flags.isPublic(delta.getNewModifiers())) {
197 									return 11;
198 								}
199 								return 80;
200 							case IDelta.METHOD:
201 								if (!Flags.isAbstract(delta.getNewModifiers())) {
202 									return 12;
203 								}
204 								return 13;
205 							case IDelta.OVERRIDEN_METHOD:
206 								return 14;
207 							case IDelta.SUPERCLASS:
208 								return 15;
209 							case IDelta.TYPE_MEMBER:
210 								return 16;
211 							case IDelta.TYPE_PARAMETERS:
212 								return 17;
213 							case IDelta.METHOD_MOVED_DOWN:
214 								return 97;
215 							case IDelta.RESTRICTIONS:
216 								return 108;
217 							default:
218 								break;
219 						}
220 						break;
221 					case IDelta.CHANGED:
222 						switch (delta.getFlags()) {
223 							case IDelta.ABSTRACT_TO_NON_ABSTRACT:
224 								return 19;
225 							case IDelta.EXPANDED_SUPERINTERFACES_SET:
226 								return 21;
227 							case IDelta.FINAL_TO_NON_FINAL:
228 								return 22;
229 							case IDelta.INCREASE_ACCESS:
230 								return 23;
231 							case IDelta.NON_FINAL_TO_FINAL:
232 								return 94;
233 							case IDelta.DECREASE_ACCESS:
234 								return 101;
235 							case IDelta.NON_ABSTRACT_TO_ABSTRACT:
236 								return 105;
237 							default:
238 								break;
239 						}
240 						break;
241 					case IDelta.REMOVED:
242 						switch (delta.getFlags()) {
243 							case IDelta.DEPRECATION:
244 								return 111;
245 							case IDelta.CLINIT:
246 								return 25;
247 							case IDelta.CONSTRUCTOR:
248 							case IDelta.API_CONSTRUCTOR:
249 								return 26;
250 							case IDelta.FIELD_MOVED_UP:
251 								return 27;
252 							case IDelta.FIELD:
253 							case IDelta.API_FIELD:
254 								if (Flags.isProtected(delta.getOldModifiers())) {
255 									return 28;
256 								}
257 								return 29;
258 							case IDelta.METHOD_MOVED_UP:
259 								return 30;
260 							case IDelta.METHOD:
261 							case IDelta.API_METHOD:
262 								if (Flags.isProtected(delta.getOldModifiers())) {
263 									return 31;
264 								}
265 								return 32;
266 							case IDelta.RESTRICTIONS:
267 								return 112;
268 							case IDelta.TYPE_MEMBER:
269 								if (Flags.isProtected(delta.getOldModifiers())) {
270 									return 33;
271 								}
272 								return 34;
273 							default:
274 								break;
275 						}
276 						break;
277 					default:
278 						break;
279 				}
280 				break;
281 			case IDelta.ENUM_ELEMENT_TYPE:
282 				switch (delta.getKind()) {
283 					case IDelta.ADDED:
284 						switch (delta.getFlags()) {
285 							case IDelta.CONSTRUCTOR:
286 								return 35;
287 							case IDelta.ENUM_CONSTANT:
288 								return 36;
289 							case IDelta.FIELD:
290 								return 59;
291 							case IDelta.METHOD:
292 								return 37;
293 							case IDelta.DEPRECATION:
294 								return 110;
295 							default:
296 								break;
297 						}
298 						break;
299 					case IDelta.REMOVED:
300 						switch (delta.getFlags()) {
301 							case IDelta.CONSTRUCTOR:
302 							case IDelta.API_CONSTRUCTOR:
303 								return 38;
304 							case IDelta.DEPRECATION:
305 								return 111;
306 							default:
307 								break;
308 						}
309 						break;
310 					case IDelta.CHANGED:
311 						switch (delta.getFlags()) {
312 							case IDelta.DECREASE_ACCESS:
313 								return 101;
314 							default:
315 								break;
316 						}
317 						break;
318 					default:
319 						break;
320 				}
321 				break;
322 			case IDelta.FIELD_ELEMENT_TYPE:
323 				switch (delta.getKind()) {
324 					case IDelta.ADDED:
325 						switch (delta.getFlags()) {
326 							case IDelta.TYPE_ARGUMENTS:
327 								return 18;
328 							case IDelta.VALUE:
329 								return 40;
330 							case IDelta.DEPRECATION:
331 								return 110;
332 							default:
333 								break;
334 						}
335 						break;
336 					case IDelta.CHANGED:
337 						switch (delta.getFlags()) {
338 							case IDelta.FINAL_TO_NON_FINAL_NON_STATIC:
339 								return 41;
340 							case IDelta.FINAL_TO_NON_FINAL_STATIC_CONSTANT:
341 								if (Flags.isProtected(delta.getNewModifiers())) {
342 									return 42;
343 								}
344 								return 43;
345 							case IDelta.FINAL_TO_NON_FINAL_STATIC_NON_CONSTANT:
346 								return 44;
347 							case IDelta.INCREASE_ACCESS:
348 								return 45;
349 							case IDelta.NON_FINAL_TO_FINAL:
350 								return 46;
351 							case IDelta.NON_TRANSIENT_TO_TRANSIENT:
352 								return 47;
353 							case IDelta.TRANSIENT_TO_NON_TRANSIENT:
354 								return 48;
355 							case IDelta.VALUE:
356 								if (Flags.isProtected(delta.getNewModifiers())) {
357 									return 50;
358 								}
359 								return 51;
360 							case IDelta.TYPE:
361 								return 78;
362 							case IDelta.NON_VOLATILE_TO_VOLATILE:
363 								return 92;
364 							case IDelta.VOLATILE_TO_NON_VOLATILE:
365 								return 93;
366 							case IDelta.DECREASE_ACCESS:
367 								return 98;
368 							case IDelta.NON_STATIC_TO_STATIC:
369 								return 103;
370 							case IDelta.STATIC_TO_NON_STATIC:
371 								return 104;
372 							default:
373 								break;
374 						}
375 						break;
376 					case IDelta.REMOVED:
377 						switch (delta.getFlags()) {
378 							case IDelta.VALUE:
379 								if (Flags.isProtected(delta.getNewModifiers())) {
380 									return 52;
381 								}
382 								return 53;
383 							case IDelta.DEPRECATION:
384 								return 111;
385 							default:
386 								break;
387 						}
388 						break;
389 					default:
390 						break;
391 				}
392 				break;
393 			case IDelta.TYPE_PARAMETER_ELEMENT_TYPE:
394 				if (delta.getKind() == IDelta.CHANGED && delta.getFlags() == IDelta.TYPE_PARAMETER_NAME) {
395 					return 24;
396 				}
397 				break;
398 			case IDelta.INTERFACE_ELEMENT_TYPE:
399 				switch (delta.getKind()) {
400 					case IDelta.ADDED:
401 						switch (delta.getFlags()) {
402 							case IDelta.DEPRECATION:
403 								return 110;
404 							case IDelta.FIELD:
405 								return 54;
406 							case IDelta.METHOD:
407 								return 55;
408 							case IDelta.TYPE_MEMBER:
409 								return 56;
410 							case IDelta.OVERRIDEN_METHOD:
411 								return 57;
412 							case IDelta.TYPE_PARAMETERS:
413 								return 58;
414 							case IDelta.METHOD_MOVED_DOWN:
415 								return 97;
416 							case IDelta.SUPER_INTERFACE_WITH_METHODS:
417 								return 107;
418 							default:
419 								break;
420 						}
421 						break;
422 					case IDelta.CHANGED:
423 						switch (delta.getFlags()) {
424 							case IDelta.EXPANDED_SUPERINTERFACES_SET:
425 								return 79;
426 							case IDelta.DECREASE_ACCESS:
427 								return 101;
428 							default:
429 								break;
430 						}
431 						break;
432 					case IDelta.REMOVED:
433 						switch (delta.getFlags()) {
434 							case IDelta.FIELD_MOVED_UP:
435 								return 60;
436 							case IDelta.METHOD_MOVED_UP:
437 								return 61;
438 							case IDelta.DEPRECATION:
439 								return 111;
440 							case IDelta.RESTRICTIONS:
441 								return 112;
442 							default:
443 								break;
444 						}
445 						break;
446 					default:
447 						break;
448 				}
449 				break;
450 			case IDelta.METHOD_ELEMENT_TYPE:
451 				switch (delta.getKind()) {
452 					case IDelta.ADDED:
453 						switch (delta.getFlags()) {
454 							case IDelta.DEPRECATION:
455 								return 110;
456 							case IDelta.ANNOTATION_DEFAULT_VALUE:
457 								return 62;
458 							case IDelta.CHECKED_EXCEPTION:
459 								return 63;
460 							case IDelta.TYPE_PARAMETERS:
461 								return 64;
462 							case IDelta.UNCHECKED_EXCEPTION:
463 								return 65;
464 							case IDelta.TYPE_ARGUMENTS:
465 								return 18;
466 							case IDelta.RESTRICTIONS:
467 								return 106;
468 							default:
469 								break;
470 						}
471 						break;
472 					case IDelta.CHANGED:
473 						switch (delta.getFlags()) {
474 							case IDelta.ABSTRACT_TO_NON_ABSTRACT:
475 								return 66;
476 							case IDelta.ANNOTATION_DEFAULT_VALUE:
477 								return 67;
478 							case IDelta.ARRAY_TO_VARARGS:
479 								return 68;
480 							case IDelta.FINAL_TO_NON_FINAL:
481 								return 69;
482 							case IDelta.INCREASE_ACCESS:
483 								return 70;
484 							case IDelta.NATIVE_TO_NON_NATIVE:
485 								return 71;
486 							case IDelta.NON_NATIVE_TO_NATIVE:
487 								return 72;
488 							case IDelta.NON_SYNCHRONIZED_TO_SYNCHRONIZED:
489 								return 73;
490 							case IDelta.SYNCHRONIZED_TO_NON_SYNCHRONIZED:
491 								return 74;
492 							case IDelta.NON_FINAL_TO_FINAL:
493 								if (RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions())) {
494 									return 81;
495 								}
496 								if (RestrictionModifiers.isOverrideRestriction(delta.getCurrentRestrictions())) {
497 									return 82;
498 								}
499 								return 83;
500 							case IDelta.NON_STATIC_TO_STATIC:
501 								return 84;
502 							case IDelta.DECREASE_ACCESS:
503 								return 99;
504 							case IDelta.STATIC_TO_NON_STATIC:
505 								return 102;
506 							default:
507 								break;
508 						}
509 						break;
510 					case IDelta.REMOVED:
511 						switch (delta.getFlags()) {
512 							case IDelta.CHECKED_EXCEPTION:
513 								return 76;
514 							case IDelta.UNCHECKED_EXCEPTION:
515 								return 77;
516 							case IDelta.DEPRECATION:
517 								return 111;
518 							default:
519 								break;
520 						}
521 						break;
522 					default:
523 						break;
524 				}
525 				break;
526 			case IDelta.CONSTRUCTOR_ELEMENT_TYPE:
527 				switch (delta.getKind()) {
528 					case IDelta.ADDED:
529 						switch (delta.getFlags()) {
530 							case IDelta.DEPRECATION:
531 								return 110;
532 							case IDelta.CHECKED_EXCEPTION:
533 								return 85;
534 							case IDelta.TYPE_PARAMETERS:
535 								return 64;
536 							case IDelta.UNCHECKED_EXCEPTION:
537 								return 86;
538 							case IDelta.TYPE_ARGUMENTS:
539 								return 18;
540 							default:
541 								break;
542 						}
543 						break;
544 					case IDelta.CHANGED:
545 						switch (delta.getFlags()) {
546 							case IDelta.ARRAY_TO_VARARGS:
547 								return 87;
548 							case IDelta.INCREASE_ACCESS:
549 								return 89;
550 							case IDelta.DECREASE_ACCESS:
551 								return 100;
552 							default:
553 								break;
554 						}
555 						break;
556 					case IDelta.REMOVED:
557 						switch (delta.getFlags()) {
558 							case IDelta.CHECKED_EXCEPTION:
559 								return 90;
560 							case IDelta.UNCHECKED_EXCEPTION:
561 								return 91;
562 							case IDelta.DEPRECATION:
563 								return 111;
564 							default:
565 								break;
566 						}
567 						break;
568 					default:
569 						break;
570 				}
571 				break;
572 			default:
573 				break;
574 		}
575 		return 0;
576 	}
577 }
578