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