001 /* 002 * CDDL HEADER START 003 * 004 * The contents of this file are subject to the terms of the 005 * Common Development and Distribution License, Version 1.0 only 006 * (the "License"). You may not use this file except in compliance 007 * with the License. 008 * 009 * You can obtain a copy of the license at 010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE 011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE. 012 * See the License for the specific language governing permissions 013 * and limitations under the License. 014 * 015 * When distributing Covered Code, include this CDDL HEADER in each 016 * file and include the License file at 017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable, 018 * add the following below this CDDL HEADER, with the fields enclosed 019 * by brackets "[]" replaced with your own identifying information: 020 * Portions Copyright [yyyy] [name of copyright owner] 021 * 022 * CDDL HEADER END 023 * 024 * 025 * Copyright 2008 Sun Microsystems, Inc. 026 */ 027 package org.opends.server.tools.dsconfig; 028 029 030 031 import static org.opends.messages.DSConfigMessages.*; 032 033 import org.opends.messages.Message; 034 import org.opends.server.admin.AbstractManagedObjectDefinition; 035 import org.opends.server.admin.DefaultBehaviorException; 036 import org.opends.server.admin.IllegalPropertyValueException; 037 import org.opends.server.admin.IllegalPropertyValueStringException; 038 import org.opends.server.admin.ManagedObjectDefinition; 039 import org.opends.server.admin.PropertyDefinition; 040 import org.opends.server.admin.PropertyDefinitionUsageBuilder; 041 import org.opends.server.admin.PropertyException; 042 import org.opends.server.admin.PropertyIsMandatoryException; 043 import org.opends.server.admin.PropertyIsReadOnlyException; 044 import org.opends.server.admin.PropertyIsSingleValuedException; 045 import org.opends.server.admin.RelationDefinition; 046 import org.opends.server.admin.client.IllegalManagedObjectNameException; 047 import org.opends.server.admin.client.ManagedObjectDecodingException; 048 import org.opends.server.admin.client.MissingMandatoryPropertiesException; 049 import org.opends.server.admin.client.OperationRejectedException; 050 import org.opends.server.util.args.Argument; 051 import org.opends.server.util.args.ArgumentException; 052 import org.opends.server.util.cli.CLIException; 053 import org.opends.server.util.cli.ConsoleApplication; 054 import org.opends.server.util.table.TableBuilder; 055 import org.opends.server.util.table.TextTablePrinter; 056 057 058 059 /** 060 * A utility class for converting various admin exception types into 061 * argument exceptions. 062 */ 063 public final class ArgumentExceptionFactory { 064 065 /** 066 * Creates a CLI exception from an illegal managed object name 067 * exception. 068 * 069 * @param e 070 * The illegal managed object name exception. 071 * @param d 072 * The managed object definition. 073 * @return Returns a CLI exception. 074 */ 075 public static CLIException adaptIllegalManagedObjectNameException( 076 IllegalManagedObjectNameException e, 077 AbstractManagedObjectDefinition<?, ?> d) { 078 String illegalName = e.getIllegalName(); 079 PropertyDefinition<?> pd = e.getNamingPropertyDefinition(); 080 081 if (illegalName.length() == 0) { 082 Message message = 083 ERR_DSCFG_ERROR_ILLEGAL_NAME_EMPTY.get(d.getUserFriendlyPluralName()); 084 return new CLIException(message); 085 } else if (illegalName.trim().length() == 0) { 086 Message message = 087 ERR_DSCFG_ERROR_ILLEGAL_NAME_BLANK.get(d.getUserFriendlyPluralName()); 088 return new CLIException(message); 089 } else if (pd != null) { 090 try { 091 pd.decodeValue(illegalName); 092 } catch (IllegalPropertyValueStringException e1) { 093 PropertyDefinitionUsageBuilder b = new PropertyDefinitionUsageBuilder( 094 true); 095 Message syntax = b.getUsage(pd); 096 097 Message message = ERR_DSCFG_ERROR_ILLEGAL_NAME_SYNTAX.get( 098 illegalName, d.getUserFriendlyName(), syntax); 099 return new CLIException(message); 100 } 101 } 102 103 Message message = ERR_DSCFG_ERROR_ILLEGAL_NAME_UNKNOWN.get( 104 illegalName, d.getUserFriendlyName()); 105 return new CLIException(message); 106 } 107 108 109 110 /** 111 * Creates an argument exception from a property exception. 112 * 113 * @param e 114 * The property exception. 115 * @param d 116 * The managed object definition. 117 * @return Returns an argument exception. 118 */ 119 public static ArgumentException adaptPropertyException(PropertyException e, 120 AbstractManagedObjectDefinition<?, ?> d) { 121 if (e instanceof IllegalPropertyValueException) { 122 IllegalPropertyValueException pe = (IllegalPropertyValueException) e; 123 return adapt(d, pe); 124 } else if (e instanceof IllegalPropertyValueStringException) { 125 IllegalPropertyValueStringException pe = 126 (IllegalPropertyValueStringException) e; 127 return adapt(d, pe); 128 } else if (e instanceof PropertyIsMandatoryException) { 129 PropertyIsMandatoryException pe = (PropertyIsMandatoryException) e; 130 return adapt(d, pe); 131 } else if (e instanceof PropertyIsSingleValuedException) { 132 PropertyIsSingleValuedException pe = (PropertyIsSingleValuedException) e; 133 return adapt(d, pe); 134 } else if (e instanceof PropertyIsReadOnlyException) { 135 PropertyIsReadOnlyException pe = (PropertyIsReadOnlyException) e; 136 return adapt(d, pe); 137 } else if (e instanceof DefaultBehaviorException) { 138 DefaultBehaviorException pe = (DefaultBehaviorException) e; 139 return adapt(d, pe); 140 } else { 141 Message message = ERR_DSCFG_ERROR_PROPERTY_UNKNOWN_ERROR. 142 get(d.getUserFriendlyName(), e.getPropertyDefinition().getName(), 143 e.getMessage()); 144 return new ArgumentException(message); 145 } 146 } 147 148 149 150 /** 151 * Displays a table listing reasons why a managed object could not 152 * be decoded successfully. 153 * 154 * @param app 155 * The console application. 156 * @param e 157 * The managed object decoding exception. 158 */ 159 public static void displayManagedObjectDecodingException( 160 ConsoleApplication app, ManagedObjectDecodingException e) { 161 AbstractManagedObjectDefinition<?, ?> d = e.getPartialManagedObject() 162 .getManagedObjectDefinition(); 163 Message ufn = d.getUserFriendlyName(); 164 Message msg; 165 if (e.getCauses().size() == 1) { 166 msg = ERR_GET_HEADING_MODE_SINGLE.get(ufn); 167 } else { 168 msg = ERR_GET_HEADING_MODE_PLURAL.get(ufn); 169 } 170 171 app.println(msg); 172 app.println(); 173 TableBuilder builder = new TableBuilder(); 174 for (PropertyException pe : e.getCauses()) { 175 ArgumentException ae = adaptPropertyException(pe, d); 176 builder.startRow(); 177 builder.appendCell("*"); 178 builder.appendCell(ae.getMessage()); 179 } 180 181 TextTablePrinter printer = new TextTablePrinter(app.getErrorStream()); 182 printer.setDisplayHeadings(false); 183 printer.setColumnWidth(1, 0); 184 printer.setIndentWidth(4); 185 builder.print(printer); 186 } 187 188 189 190 /** 191 * Displays a table listing missing mandatory properties. 192 * 193 * @param app 194 * The console application. 195 * @param e 196 * The missing mandatory property exception. 197 */ 198 public static void displayMissingMandatoryPropertyException( 199 ConsoleApplication app, MissingMandatoryPropertiesException e) { 200 Message ufn = e.getUserFriendlyName(); 201 Message msg; 202 if (e.isCreate()) { 203 if (e.getCauses().size() == 1) { 204 msg = ERR_CREATE_HEADING_MMPE_SINGLE.get(ufn); 205 } else { 206 msg = ERR_CREATE_HEADING_MMPE_PLURAL.get(ufn); 207 } 208 } else { 209 if (e.getCauses().size() == 1) { 210 msg = ERR_MODIFY_HEADING_MMPE_SINGLE.get(ufn); 211 } else { 212 msg = ERR_MODIFY_HEADING_MMPE_PLURAL.get(ufn); 213 } 214 } 215 216 app.println(msg); 217 app.println(); 218 TableBuilder builder = new TableBuilder(); 219 builder.addSortKey(0); 220 builder.appendHeading(INFO_DSCFG_HEADING_PROPERTY_NAME.get()); 221 builder.appendHeading(INFO_DSCFG_HEADING_PROPERTY_SYNTAX.get()); 222 223 PropertyDefinitionUsageBuilder b = new PropertyDefinitionUsageBuilder(true); 224 for (PropertyIsMandatoryException pe : e.getCauses()) { 225 PropertyDefinition<?> pd = pe.getPropertyDefinition(); 226 builder.startRow(); 227 builder.appendCell(pd.getName()); 228 builder.appendCell(b.getUsage(pd)); 229 } 230 231 TextTablePrinter printer = new TextTablePrinter(app.getErrorStream()); 232 printer.setDisplayHeadings(true); 233 printer.setColumnWidth(1, 0); 234 printer.setIndentWidth(4); 235 builder.print(printer); 236 } 237 238 239 240 /** 241 * Displays a table listing the reasons why an operation was 242 * rejected. 243 * 244 * @param app 245 * The console application. 246 * @param e 247 * The operation rejected exception. 248 */ 249 public static void displayOperationRejectedException(ConsoleApplication app, 250 OperationRejectedException e) { 251 Message ufn = e.getUserFriendlyName(); 252 Message msg; 253 switch (e.getOperationType()) { 254 case CREATE: 255 if (e.getMessages().size() == 1) { 256 msg = ERR_DSCFG_ERROR_CREATE_ORE_SINGLE.get(ufn); 257 } else { 258 msg = ERR_DSCFG_ERROR_CREATE_ORE_PLURAL.get(ufn); 259 } 260 break; 261 case DELETE: 262 if (e.getMessages().size() == 1) { 263 msg = ERR_DSCFG_ERROR_DELETE_ORE_SINGLE.get(ufn); 264 } else { 265 msg = ERR_DSCFG_ERROR_DELETE_ORE_PLURAL.get(ufn); 266 } 267 break; 268 default: 269 if (e.getMessages().size() == 1) { 270 msg = ERR_DSCFG_ERROR_MODIFY_ORE_SINGLE.get(ufn); 271 } else { 272 msg = ERR_DSCFG_ERROR_MODIFY_ORE_PLURAL.get(ufn); 273 } 274 break; 275 } 276 277 app.println(msg); 278 app.println(); 279 TableBuilder builder = new TableBuilder(); 280 for (Message reason : e.getMessages()) { 281 builder.startRow(); 282 builder.appendCell("*"); 283 builder.appendCell(reason); 284 } 285 TextTablePrinter printer = new TextTablePrinter(app.getErrorStream()); 286 printer.setDisplayHeadings(false); 287 printer.setColumnWidth(1, 0); 288 printer.setIndentWidth(4); 289 builder.print(printer); 290 } 291 292 293 294 /** 295 * Creates an argument exception which should be used when a 296 * property modification argument is incompatible with a previous 297 * modification argument. 298 * 299 * @param arg 300 * The incompatible argument. 301 * @return Returns an argument exception. 302 */ 303 public static ArgumentException incompatiblePropertyModification(String arg) { 304 Message msg = ERR_DSCFG_ERROR_INCOMPATIBLE_PROPERTY_MOD.get(arg); 305 return new ArgumentException(msg); 306 } 307 308 309 310 /** 311 * Creates an argument exception which should be used when the 312 * client has not specified a bind password. 313 * 314 * @param bindDN 315 * The name of the user requiring a password. 316 * @return Returns an argument exception. 317 */ 318 public static ArgumentException missingBindPassword(String bindDN) { 319 Message msg = ERR_DSCFG_ERROR_NO_PASSWORD.get(bindDN); 320 return new ArgumentException(msg); 321 } 322 323 324 325 /** 326 * Creates an argument exception which should be used when an 327 * argument, which is mandatory when the application is 328 * non-interactive, has not been specified. 329 * 330 * @param arg 331 * The missing argument. 332 * @return Returns an argument exception. 333 */ 334 public static ArgumentException missingMandatoryNonInteractiveArgument( 335 Argument arg) { 336 Message msg = ERR_DSCFG_ERROR_MISSING_NON_INTERACTIVE_ARG.get( 337 arg.getLongIdentifier()); 338 return new ArgumentException(msg); 339 } 340 341 342 343 /** 344 * Creates an argument exception which should be used when a 345 * property value argument is invalid because it does not a property 346 * name. 347 * 348 * @param arg 349 * The argument having the missing property name. 350 * @return Returns an argument exception. 351 */ 352 public static ArgumentException missingNameInPropertyArgument(String arg) { 353 Message msg = ERR_DSCFG_ERROR_NO_NAME_IN_PROPERTY_VALUE.get(arg); 354 return new ArgumentException(msg); 355 } 356 357 358 359 /** 360 * Creates an argument exception which should be used when a 361 * property modification argument is invalid because it does not a 362 * property name. 363 * 364 * @param arg 365 * The argument having the missing property name. 366 * @return Returns an argument exception. 367 */ 368 public static ArgumentException missingNameInPropertyModification( 369 String arg) { 370 Message msg = ERR_DSCFG_ERROR_NO_NAME_IN_PROPERTY_MOD.get(arg); 371 return new ArgumentException(msg); 372 } 373 374 375 376 /** 377 * Creates an argument exception which should be used when a 378 * property value argument is invalid because it does not contain a 379 * separator between the property name and its value. 380 * 381 * @param arg 382 * The argument having a missing separator. 383 * @return Returns an argument exception. 384 */ 385 public static ArgumentException missingSeparatorInPropertyArgument( 386 String arg) { 387 Message msg = ERR_DSCFG_ERROR_NO_SEPARATOR_IN_PROPERTY_VALUE.get(arg); 388 return new ArgumentException(msg); 389 } 390 391 392 393 /** 394 * Creates an argument exception which should be used when a 395 * property modification argument is invalid because it does not 396 * contain a separator between the property name and its value. 397 * 398 * @param arg 399 * The argument having a missing separator. 400 * @return Returns an argument exception. 401 */ 402 public static ArgumentException missingSeparatorInPropertyModification( 403 String arg) { 404 Message msg = ERR_DSCFG_ERROR_NO_SEPARATOR_IN_PROPERTY_MOD.get(arg); 405 return new ArgumentException(msg); 406 } 407 408 409 410 /** 411 * Creates an argument exception which should be used when a 412 * property value argument is invalid because it does not a property 413 * value. 414 * 415 * @param arg 416 * The argument having the missing property value. 417 * @return Returns an argument exception. 418 */ 419 public static ArgumentException missingValueInPropertyArgument(String arg) { 420 Message msg = ERR_DSCFG_ERROR_NO_VALUE_IN_PROPERTY_VALUE.get(arg); 421 return new ArgumentException(msg); 422 } 423 424 425 426 /** 427 * Creates an argument exception which should be used when a 428 * property modification argument is invalid because it does not a 429 * property value. 430 * 431 * @param arg 432 * The argument having the missing property value. 433 * @return Returns an argument exception. 434 */ 435 public static ArgumentException missingValueInPropertyModification( 436 String arg) { 437 Message msg = ERR_DSCFG_ERROR_NO_NAME_IN_PROPERTY_MOD.get(arg); 438 return new ArgumentException(msg); 439 } 440 441 442 443 /** 444 * Creates an argument exception which should be used when the 445 * connection parameters could not be read from the standard input. 446 * 447 * @param cause 448 * The reason why the connection parameters could not be 449 * read. 450 * @return Returns an argument exception. 451 */ 452 public static ArgumentException unableToReadConnectionParameters( 453 Exception cause) { 454 Message message = ERR_DSCFG_ERROR_CANNOT_READ_CONNECTION_PARAMETERS 455 .get(cause.getMessage()); 456 return new ArgumentException(message, cause); 457 } 458 459 460 461 /** 462 * Creates an argument exception which should be used when the bind 463 * password could not be read from the standard input because the 464 * application is non-interactive. 465 * 466 * @return Returns an argument exception. 467 */ 468 public static ArgumentException unableToReadBindPasswordInteractively() { 469 Message message = ERR_DSCFG_ERROR_BIND_PASSWORD_NONINTERACTIVE.get(); 470 return new ArgumentException(message); 471 } 472 473 474 475 /** 476 * Creates an argument exception which should be used when an 477 * attempt is made to reset a mandatory property that does not have 478 * any default values. 479 * 480 * @param d 481 * The managed object definition. 482 * @param name 483 * The name of the mandatory property. 484 * @param setOption 485 * The name of the option which should be used to set the 486 * property's values. 487 * @return Returns an argument exception. 488 */ 489 public static ArgumentException unableToResetMandatoryProperty( 490 AbstractManagedObjectDefinition<?, ?> d, String name, String setOption) { 491 Message message = ERR_DSCFG_ERROR_UNABLE_TO_RESET_MANDATORY_PROPERTY.get( 492 d.getUserFriendlyPluralName(), name, setOption); 493 return new ArgumentException(message); 494 } 495 496 497 498 /** 499 * Creates an argument exception which should be used when an 500 * attempt is made to set the naming property for a managed object 501 * during creation. 502 * 503 * @param d 504 * The managed object definition. 505 * @param pd 506 * The naming property definition. 507 * @return Returns an argument exception. 508 */ 509 public static ArgumentException unableToSetNamingProperty( 510 AbstractManagedObjectDefinition<?, ?> d, PropertyDefinition<?> pd) { 511 Message message = ERR_DSCFG_ERROR_UNABLE_TO_SET_NAMING_PROPERTY.get( 512 pd.getName(), d.getUserFriendlyName()); 513 return new ArgumentException(message); 514 } 515 516 517 518 /** 519 * Creates an argument exception which should be used when a 520 * component category argument is not recognized. 521 * 522 * @param categoryName 523 * The unrecognized component category. 524 * @return Returns an argument exception. 525 */ 526 public static ArgumentException unknownCategory(String categoryName) { 527 Message msg = ERR_DSCFG_ERROR_CATEGORY_UNRECOGNIZED.get(categoryName); 528 return new ArgumentException(msg); 529 } 530 531 532 533 /** 534 * Creates an argument exception which should be used when a 535 * property name is not recognized. 536 * 537 * @param d 538 * The managed object definition. 539 * @param name 540 * The unrecognized property name. 541 * @return Returns an argument exception. 542 */ 543 public static ArgumentException unknownProperty( 544 AbstractManagedObjectDefinition<?, ?> d, String name) { 545 Message message = ERR_DSCFG_ERROR_PROPERTY_UNRECOGNIZED.get( 546 name, d.getUserFriendlyPluralName()); 547 return new ArgumentException(message); 548 } 549 550 551 552 /** 553 * Creates an argument exception which should be used when a 554 * property name is not recognized. 555 * 556 * @param name 557 * The unrecognized property name. 558 * @return Returns an argument exception. 559 */ 560 public static ArgumentException unknownProperty(String name) { 561 Message message = ERR_DSCFG_ERROR_PROPERTY_UNRECOGNIZED_NO_DEFN.get(name); 562 return new ArgumentException(message); 563 } 564 565 566 567 /** 568 * Creates an argument exception which should be used when a 569 * sub-type argument in a create-xxx sub-command is not recognized. 570 * 571 * @param r 572 * The relation definition. 573 * @param typeName 574 * The unrecognized property sub-type. 575 * @param typeUsage 576 * A usage string describing the allowed sub-types. 577 * @return Returns an argument exception. 578 */ 579 public static ArgumentException unknownSubType(RelationDefinition<?, ?> r, 580 String typeName, String typeUsage) { 581 Message msg = ERR_DSCFG_ERROR_SUB_TYPE_UNRECOGNIZED.get( 582 typeName, r.getUserFriendlyName(), typeUsage); 583 return new ArgumentException(msg); 584 } 585 586 587 /** 588 * Creates an argument exception which should be used when a managed 589 * object type argument is not associated with a category. 590 * 591 * @param categoryName 592 * The component category. 593 * @param typeName 594 * The unrecognized component type. 595 * @return Returns an argument exception. 596 */ 597 public static ArgumentException unknownTypeForCategory(String typeName, 598 String categoryName) { 599 Message msg = 600 ERR_DSCFG_ERROR_CATEGORY_TYPE_UNRECOGNIZED.get(typeName, categoryName); 601 return new ArgumentException(msg); 602 } 603 604 605 606 /** 607 * Creates a CLI exception which should be used when a managed 608 * object is retrieved but does not have the correct type 609 * appropriate for the associated sub-command. 610 * 611 * @param r 612 * The relation definition. 613 * @param d 614 * The definition of the managed object that was retrieved. 615 * 616 * @param subcommandName the sub-command name. 617 * @return Returns a CLI exception. 618 */ 619 public static CLIException wrongManagedObjectType(RelationDefinition<?, ?> r, 620 ManagedObjectDefinition<?, ?> d, String subcommandName) { 621 Message msg = ERR_DSCFG_ERROR_TYPE_UNRECOGNIZED_FOR_SUBCOMMAND.get( 622 d.getUserFriendlyName(), subcommandName); 623 return new CLIException(msg); 624 } 625 626 627 628 /** 629 * Creates an argument exception from a default behavior exception. 630 * 631 * @param d 632 * The managed object definition. 633 * @param e 634 * The default behavior exception. 635 * @return Returns an argument exception. 636 */ 637 private static ArgumentException adapt( 638 AbstractManagedObjectDefinition<?, ?> d, DefaultBehaviorException e) { 639 Message message = ERR_DSCFG_ERROR_PROPERTY_DEFAULT_BEHAVIOR. 640 get(d.getUserFriendlyName(), e.getPropertyDefinition().getName(), 641 e.getMessage()); 642 return new ArgumentException(message); 643 } 644 645 646 647 /** 648 * Creates an argument exception from an illegal property value 649 * exception. 650 * 651 * @param d 652 * The managed object definition. 653 * @param e 654 * The illegal property value exception. 655 * @return Returns an argument exception. 656 */ 657 private static ArgumentException adapt( 658 AbstractManagedObjectDefinition<?, ?> d, 659 IllegalPropertyValueException e) { 660 PropertyDefinitionUsageBuilder b = new PropertyDefinitionUsageBuilder(true); 661 Message syntax = b.getUsage(e.getPropertyDefinition()); 662 663 if (syntax.length() > 20) { 664 // syntax = 665 // INFO_DSCFG_DESCRIPTION_PROPERTY_SYNTAX_HELP.get(); 666 } 667 668 Message message = ERR_DSCFG_ERROR_PROPERTY_INVALID_VALUE. 669 get(String.valueOf(e.getIllegalValue()), d.getUserFriendlyName(), 670 e.getPropertyDefinition().getName(), syntax); 671 return new ArgumentException(message); 672 } 673 674 675 676 /** 677 * Creates an argument exception from an illegal property string 678 * value exception. 679 * 680 * @param d 681 * The managed object definition. 682 * @param e 683 * The illegal property string value exception. 684 * @return Returns an argument exception. 685 */ 686 private static ArgumentException adapt( 687 AbstractManagedObjectDefinition<?, ?> d, 688 IllegalPropertyValueStringException e) { 689 PropertyDefinitionUsageBuilder b = new PropertyDefinitionUsageBuilder(true); 690 Message syntax = b.getUsage(e.getPropertyDefinition()); 691 692 if (syntax.length() > 20) { 693 // syntax = 694 // INFO_DSCFG_DESCRIPTION_PROPERTY_SYNTAX_HELP.get(); 695 } 696 697 Message message = ERR_DSCFG_ERROR_PROPERTY_INVALID_VALUE. 698 get(String.valueOf(e.getIllegalValueString()), d.getUserFriendlyName(), 699 e.getPropertyDefinition().getName(), syntax); 700 return new ArgumentException(message); 701 } 702 703 704 705 /** 706 * Creates an argument exception from a property is mandatory 707 * exception. 708 * 709 * @param d 710 * The managed object definition. 711 * @param e 712 * The property is mandatory exception. 713 * @return Returns an argument exception. 714 */ 715 private static ArgumentException adapt( 716 AbstractManagedObjectDefinition<?, ?> d, 717 PropertyIsMandatoryException e) { 718 Message message = ERR_DSCFG_ERROR_PROPERTY_MANDATORY.get( 719 d.getUserFriendlyName(), e.getPropertyDefinition().getName()); 720 return new ArgumentException(message); 721 } 722 723 724 725 /** 726 * Creates an argument exception from a property is read-only 727 * exception. 728 * 729 * @param d 730 * The managed object definition. 731 * @param e 732 * The property is read-only exception. 733 * @return Returns an argument exception. 734 */ 735 private static ArgumentException adapt( 736 AbstractManagedObjectDefinition<?, ?> d, 737 PropertyIsReadOnlyException e) { 738 Message message = ERR_DSCFG_ERROR_PROPERTY_READ_ONLY.get( 739 d.getUserFriendlyName(), e.getPropertyDefinition().getName()); 740 return new ArgumentException(message); 741 } 742 743 744 745 /** 746 * Creates an argument exception from a property is single-valued 747 * exception. 748 * 749 * @param d 750 * The managed object definition. 751 * @param e 752 * The property is single-valued exception. 753 * @return Returns an argument exception. 754 */ 755 private static ArgumentException adapt( 756 AbstractManagedObjectDefinition<?, ?> d, 757 PropertyIsSingleValuedException e) { 758 Message message = ERR_DSCFG_ERROR_PROPERTY_SINGLE_VALUED.get( 759 d.getUserFriendlyName(), e.getPropertyDefinition().getName()); 760 return new ArgumentException(message); 761 } 762 763 764 765 // Prevent instantiation. 766 private ArgumentExceptionFactory() { 767 // No implementation required. 768 } 769 }