001// license-header java merge-point 002// 003// Attention: generated code (by MetafacadeLogic.vsl) - do not modify! 004// 005package org.andromda.cartridges.jsf.metafacades; 006 007import java.util.Collection; 008import java.util.List; 009import org.andromda.core.common.Introspector; 010import org.andromda.core.metafacade.MetafacadeBase; 011import org.andromda.core.metafacade.MetafacadeFactory; 012import org.andromda.core.metafacade.ModelValidationMessage; 013import org.andromda.metafacades.uml.ClassifierFacade; 014import org.andromda.metafacades.uml.ConstraintFacade; 015import org.andromda.metafacades.uml.DependencyFacade; 016import org.andromda.metafacades.uml.EventFacade; 017import org.andromda.metafacades.uml.FrontEndAction; 018import org.andromda.metafacades.uml.FrontEndControllerOperation; 019import org.andromda.metafacades.uml.FrontEndParameter; 020import org.andromda.metafacades.uml.FrontEndView; 021import org.andromda.metafacades.uml.ModelElementFacade; 022import org.andromda.metafacades.uml.ModelFacade; 023import org.andromda.metafacades.uml.OperationFacade; 024import org.andromda.metafacades.uml.PackageFacade; 025import org.andromda.metafacades.uml.StateMachineFacade; 026import org.andromda.metafacades.uml.StereotypeFacade; 027import org.andromda.metafacades.uml.TaggedValueFacade; 028import org.andromda.metafacades.uml.TemplateParameterFacade; 029import org.andromda.metafacades.uml.TypeMappings; 030import org.apache.log4j.Logger; 031 032/** 033 * Represents a parameter in a JSF front-end. 034 * MetafacadeLogic for JSFParameter 035 * 036 * @see JSFParameter 037 */ 038public abstract class JSFParameterLogic 039 extends MetafacadeBase 040 implements JSFParameter 041{ 042 /** 043 * The underlying UML object 044 * @see Object 045 */ 046 protected Object metaObject; 047 048 /** Create Metafacade implementation instance using the MetafacadeFactory from the context 049 * @param metaObjectIn 050 * @param context 051 */ 052 protected JSFParameterLogic(Object metaObjectIn, String context) 053 { 054 super(metaObjectIn, getContext(context)); 055 this.superFrontEndParameter = 056 (FrontEndParameter) 057 MetafacadeFactory.getInstance().createFacadeImpl( 058 "org.andromda.metafacades.uml.FrontEndParameter", 059 metaObjectIn, 060 getContext(context)); 061 this.metaObject = metaObjectIn; 062 } 063 064 /** 065 * The logger instance. 066 */ 067 private static final Logger logger = Logger.getLogger(JSFParameterLogic.class); 068 069 /** 070 * Gets the context for this metafacade logic instance. 071 * @param context String. Set to JSFParameter if null 072 * @return context String 073 */ 074 private static String getContext(String context) 075 { 076 if (context == null) 077 { 078 context = "org.andromda.cartridges.jsf.metafacades.JSFParameter"; 079 } 080 return context; 081 } 082 083 private FrontEndParameter superFrontEndParameter; 084 private boolean superFrontEndParameterInitialized = false; 085 086 /** 087 * Gets the FrontEndParameter parent instance. 088 * @return this.superFrontEndParameter FrontEndParameter 089 */ 090 private FrontEndParameter getSuperFrontEndParameter() 091 { 092 if (!this.superFrontEndParameterInitialized) 093 { 094 ((MetafacadeBase)this.superFrontEndParameter).setMetafacadeContext(this.getMetafacadeContext()); 095 this.superFrontEndParameterInitialized = true; 096 } 097 return this.superFrontEndParameter; 098 } 099 100 /** Reset context only for non-root metafacades 101 * @param context 102 * @see org.andromda.core.metafacade.MetafacadeBase#resetMetafacadeContext(String context) 103 */ 104 @Override 105 public void resetMetafacadeContext(String context) 106 { 107 if (!this.contextRoot) // reset context only for non-root metafacades 108 { 109 context = getContext(context); // to have same value as in original constructor call 110 setMetafacadeContext (context); 111 if (this.superFrontEndParameterInitialized) 112 { 113 ((MetafacadeBase)this.superFrontEndParameter).resetMetafacadeContext(context); 114 } 115 } 116 } 117 118 /** 119 * @return boolean true always 120 * @see JSFParameter 121 */ 122 public boolean isJSFParameterMetaType() 123 { 124 return true; 125 } 126 127 // --------------- attributes --------------------- 128 129 /** 130 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getMessageKey() 131 * @return String 132 */ 133 protected abstract String handleGetMessageKey(); 134 135 private String __messageKey1a; 136 private boolean __messageKey1aSet = false; 137 138 /** 139 * The default message key for this parameter. 140 * @return (String)handleGetMessageKey() 141 */ 142 public final String getMessageKey() 143 { 144 String messageKey1a = this.__messageKey1a; 145 if (!this.__messageKey1aSet) 146 { 147 // messageKey has no pre constraints 148 messageKey1a = handleGetMessageKey(); 149 // messageKey has no post constraints 150 this.__messageKey1a = messageKey1a; 151 if (isMetafacadePropertyCachingEnabled()) 152 { 153 this.__messageKey1aSet = true; 154 } 155 } 156 return messageKey1a; 157 } 158 159 /** 160 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getMessageValue() 161 * @return String 162 */ 163 protected abstract String handleGetMessageValue(); 164 165 private String __messageValue2a; 166 private boolean __messageValue2aSet = false; 167 168 /** 169 * The default message value for this parameter. 170 * @return (String)handleGetMessageValue() 171 */ 172 public final String getMessageValue() 173 { 174 String messageValue2a = this.__messageValue2a; 175 if (!this.__messageValue2aSet) 176 { 177 // messageValue has no pre constraints 178 messageValue2a = handleGetMessageValue(); 179 // messageValue has no post constraints 180 this.__messageValue2a = messageValue2a; 181 if (isMetafacadePropertyCachingEnabled()) 182 { 183 this.__messageValue2aSet = true; 184 } 185 } 186 return messageValue2a; 187 } 188 189 /** 190 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getDocumentationKey() 191 * @return String 192 */ 193 protected abstract String handleGetDocumentationKey(); 194 195 private String __documentationKey3a; 196 private boolean __documentationKey3aSet = false; 197 198 /** 199 * A resource message key suited for the parameter's documentation. 200 * @return (String)handleGetDocumentationKey() 201 */ 202 public final String getDocumentationKey() 203 { 204 String documentationKey3a = this.__documentationKey3a; 205 if (!this.__documentationKey3aSet) 206 { 207 // documentationKey has no pre constraints 208 documentationKey3a = handleGetDocumentationKey(); 209 // documentationKey has no post constraints 210 this.__documentationKey3a = documentationKey3a; 211 if (isMetafacadePropertyCachingEnabled()) 212 { 213 this.__documentationKey3aSet = true; 214 } 215 } 216 return documentationKey3a; 217 } 218 219 /** 220 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getDocumentationValue() 221 * @return String 222 */ 223 protected abstract String handleGetDocumentationValue(); 224 225 private String __documentationValue4a; 226 private boolean __documentationValue4aSet = false; 227 228 /** 229 * A resource message value suited for the parameter's documentation. 230 * @return (String)handleGetDocumentationValue() 231 */ 232 public final String getDocumentationValue() 233 { 234 String documentationValue4a = this.__documentationValue4a; 235 if (!this.__documentationValue4aSet) 236 { 237 // documentationValue has no pre constraints 238 documentationValue4a = handleGetDocumentationValue(); 239 // documentationValue has no post constraints 240 this.__documentationValue4a = documentationValue4a; 241 if (isMetafacadePropertyCachingEnabled()) 242 { 243 this.__documentationValue4aSet = true; 244 } 245 } 246 return documentationValue4a; 247 } 248 249 /** 250 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getFormat() 251 * @return String 252 */ 253 protected abstract String handleGetFormat(); 254 255 private String __format5a; 256 private boolean __format5aSet = false; 257 258 /** 259 * If this parameter represents a date or time this method will return the format in which it 260 * must be represented. In the event this format has not been specified by the any tagged value 261 * the default will be used. 262 * @return (String)handleGetFormat() 263 */ 264 public final String getFormat() 265 { 266 String format5a = this.__format5a; 267 if (!this.__format5aSet) 268 { 269 // format has no pre constraints 270 format5a = handleGetFormat(); 271 // format has no post constraints 272 this.__format5a = format5a; 273 if (isMetafacadePropertyCachingEnabled()) 274 { 275 this.__format5aSet = true; 276 } 277 } 278 return format5a; 279 } 280 281 /** 282 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isStrictDateFormat() 283 * @return boolean 284 */ 285 protected abstract boolean handleIsStrictDateFormat(); 286 287 private boolean __strictDateFormat6a; 288 private boolean __strictDateFormat6aSet = false; 289 290 /** 291 * Indicates where or not the date format is to be strictly respected. Otherwise the date 292 * formatter used for the representation of this date is to be set to lenient. 293 * @return (boolean)handleIsStrictDateFormat() 294 */ 295 public final boolean isStrictDateFormat() 296 { 297 boolean strictDateFormat6a = this.__strictDateFormat6a; 298 if (!this.__strictDateFormat6aSet) 299 { 300 // strictDateFormat has no pre constraints 301 strictDateFormat6a = handleIsStrictDateFormat(); 302 // strictDateFormat has no post constraints 303 this.__strictDateFormat6a = strictDateFormat6a; 304 if (isMetafacadePropertyCachingEnabled()) 305 { 306 this.__strictDateFormat6aSet = true; 307 } 308 } 309 return strictDateFormat6a; 310 } 311 312 /** 313 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getDateFormatter() 314 * @return String 315 */ 316 protected abstract String handleGetDateFormatter(); 317 318 private String __dateFormatter7a; 319 private boolean __dateFormatter7aSet = false; 320 321 /** 322 * The name of the date formatter for this parameter (if this parameter represents a date). 323 * @return (String)handleGetDateFormatter() 324 */ 325 public final String getDateFormatter() 326 { 327 String dateFormatter7a = this.__dateFormatter7a; 328 if (!this.__dateFormatter7aSet) 329 { 330 // dateFormatter has no pre constraints 331 dateFormatter7a = handleGetDateFormatter(); 332 // dateFormatter has no post constraints 333 this.__dateFormatter7a = dateFormatter7a; 334 if (isMetafacadePropertyCachingEnabled()) 335 { 336 this.__dateFormatter7aSet = true; 337 } 338 } 339 return dateFormatter7a; 340 } 341 342 /** 343 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getTimeFormatter() 344 * @return String 345 */ 346 protected abstract String handleGetTimeFormatter(); 347 348 private String __timeFormatter8a; 349 private boolean __timeFormatter8aSet = false; 350 351 /** 352 * The name of the time formatter (if this parameter represents a time). 353 * @return (String)handleGetTimeFormatter() 354 */ 355 public final String getTimeFormatter() 356 { 357 String timeFormatter8a = this.__timeFormatter8a; 358 if (!this.__timeFormatter8aSet) 359 { 360 // timeFormatter has no pre constraints 361 timeFormatter8a = handleGetTimeFormatter(); 362 // timeFormatter has no post constraints 363 this.__timeFormatter8a = timeFormatter8a; 364 if (isMetafacadePropertyCachingEnabled()) 365 { 366 this.__timeFormatter8aSet = true; 367 } 368 } 369 return timeFormatter8a; 370 } 371 372 /** 373 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isInputCheckbox() 374 * @return boolean 375 */ 376 protected abstract boolean handleIsInputCheckbox(); 377 378 private boolean __inputCheckbox9a; 379 private boolean __inputCheckbox9aSet = false; 380 381 /** 382 * Indicates if this parameter represents a checkbox widget. 383 * @return (boolean)handleIsInputCheckbox() 384 */ 385 public final boolean isInputCheckbox() 386 { 387 boolean inputCheckbox9a = this.__inputCheckbox9a; 388 if (!this.__inputCheckbox9aSet) 389 { 390 // inputCheckbox has no pre constraints 391 inputCheckbox9a = handleIsInputCheckbox(); 392 // inputCheckbox has no post constraints 393 this.__inputCheckbox9a = inputCheckbox9a; 394 if (isMetafacadePropertyCachingEnabled()) 395 { 396 this.__inputCheckbox9aSet = true; 397 } 398 } 399 return inputCheckbox9a; 400 } 401 402 /** 403 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isInputTextarea() 404 * @return boolean 405 */ 406 protected abstract boolean handleIsInputTextarea(); 407 408 private boolean __inputTextarea10a; 409 private boolean __inputTextarea10aSet = false; 410 411 /** 412 * Indicates if this parameter represents as an input text area widget. 413 * @return (boolean)handleIsInputTextarea() 414 */ 415 public final boolean isInputTextarea() 416 { 417 boolean inputTextarea10a = this.__inputTextarea10a; 418 if (!this.__inputTextarea10aSet) 419 { 420 // inputTextarea has no pre constraints 421 inputTextarea10a = handleIsInputTextarea(); 422 // inputTextarea has no post constraints 423 this.__inputTextarea10a = inputTextarea10a; 424 if (isMetafacadePropertyCachingEnabled()) 425 { 426 this.__inputTextarea10aSet = true; 427 } 428 } 429 return inputTextarea10a; 430 } 431 432 /** 433 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isInputSelect() 434 * @return boolean 435 */ 436 protected abstract boolean handleIsInputSelect(); 437 438 private boolean __inputSelect11a; 439 private boolean __inputSelect11aSet = false; 440 441 /** 442 * Indicates whether or not this parameter represents an input select widget. 443 * @return (boolean)handleIsInputSelect() 444 */ 445 public final boolean isInputSelect() 446 { 447 boolean inputSelect11a = this.__inputSelect11a; 448 if (!this.__inputSelect11aSet) 449 { 450 // inputSelect has no pre constraints 451 inputSelect11a = handleIsInputSelect(); 452 // inputSelect has no post constraints 453 this.__inputSelect11a = inputSelect11a; 454 if (isMetafacadePropertyCachingEnabled()) 455 { 456 this.__inputSelect11aSet = true; 457 } 458 } 459 return inputSelect11a; 460 } 461 462 /** 463 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isInputSecret() 464 * @return boolean 465 */ 466 protected abstract boolean handleIsInputSecret(); 467 468 private boolean __inputSecret12a; 469 private boolean __inputSecret12aSet = false; 470 471 /** 472 * Indicates whether or not this parameter represents an input "secret" widget (i.e. password). 473 * @return (boolean)handleIsInputSecret() 474 */ 475 public final boolean isInputSecret() 476 { 477 boolean inputSecret12a = this.__inputSecret12a; 478 if (!this.__inputSecret12aSet) 479 { 480 // inputSecret has no pre constraints 481 inputSecret12a = handleIsInputSecret(); 482 // inputSecret has no post constraints 483 this.__inputSecret12a = inputSecret12a; 484 if (isMetafacadePropertyCachingEnabled()) 485 { 486 this.__inputSecret12aSet = true; 487 } 488 } 489 return inputSecret12a; 490 } 491 492 /** 493 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isInputHidden() 494 * @return boolean 495 */ 496 protected abstract boolean handleIsInputHidden(); 497 498 private boolean __inputHidden13a; 499 private boolean __inputHidden13aSet = false; 500 501 /** 502 * Indicates whether or not this parameter represents a hidden input widget. 503 * @return (boolean)handleIsInputHidden() 504 */ 505 public final boolean isInputHidden() 506 { 507 boolean inputHidden13a = this.__inputHidden13a; 508 if (!this.__inputHidden13aSet) 509 { 510 // inputHidden has no pre constraints 511 inputHidden13a = handleIsInputHidden(); 512 // inputHidden has no post constraints 513 this.__inputHidden13a = inputHidden13a; 514 if (isMetafacadePropertyCachingEnabled()) 515 { 516 this.__inputHidden13aSet = true; 517 } 518 } 519 return inputHidden13a; 520 } 521 522 /** 523 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isPlaintext() 524 * @return boolean 525 */ 526 protected abstract boolean handleIsPlaintext(); 527 528 private boolean __plaintext14a; 529 private boolean __plaintext14aSet = false; 530 531 /** 532 * Indicates whether or not this field should be rendered as plain text (not as a widget). 533 * @return (boolean)handleIsPlaintext() 534 */ 535 public final boolean isPlaintext() 536 { 537 boolean plaintext14a = this.__plaintext14a; 538 if (!this.__plaintext14aSet) 539 { 540 // plaintext has no pre constraints 541 plaintext14a = handleIsPlaintext(); 542 // plaintext has no post constraints 543 this.__plaintext14a = plaintext14a; 544 if (isMetafacadePropertyCachingEnabled()) 545 { 546 this.__plaintext14aSet = true; 547 } 548 } 549 return plaintext14a; 550 } 551 552 /** 553 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isInputRadio() 554 * @return boolean 555 */ 556 protected abstract boolean handleIsInputRadio(); 557 558 private boolean __inputRadio15a; 559 private boolean __inputRadio15aSet = false; 560 561 /** 562 * Indicates whether or not this parameter should be rendered as an input radio widget. 563 * @return (boolean)handleIsInputRadio() 564 */ 565 public final boolean isInputRadio() 566 { 567 boolean inputRadio15a = this.__inputRadio15a; 568 if (!this.__inputRadio15aSet) 569 { 570 // inputRadio has no pre constraints 571 inputRadio15a = handleIsInputRadio(); 572 // inputRadio has no post constraints 573 this.__inputRadio15a = inputRadio15a; 574 if (isMetafacadePropertyCachingEnabled()) 575 { 576 this.__inputRadio15aSet = true; 577 } 578 } 579 return inputRadio15a; 580 } 581 582 /** 583 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isInputText() 584 * @return boolean 585 */ 586 protected abstract boolean handleIsInputText(); 587 588 private boolean __inputText16a; 589 private boolean __inputText16aSet = false; 590 591 /** 592 * Indicates whether or not this parameter should be rendered as a text input widget. 593 * @return (boolean)handleIsInputText() 594 */ 595 public final boolean isInputText() 596 { 597 boolean inputText16a = this.__inputText16a; 598 if (!this.__inputText16aSet) 599 { 600 // inputText has no pre constraints 601 inputText16a = handleIsInputText(); 602 // inputText has no post constraints 603 this.__inputText16a = inputText16a; 604 if (isMetafacadePropertyCachingEnabled()) 605 { 606 this.__inputText16aSet = true; 607 } 608 } 609 return inputText16a; 610 } 611 612 /** 613 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getBackingListName() 614 * @return String 615 */ 616 protected abstract String handleGetBackingListName(); 617 618 private String __backingListName17a; 619 private boolean __backingListName17aSet = false; 620 621 /** 622 * The backing list name for this parameter. This is useful if you want to be able to select the 623 * parameter value from a list (i.e. a drop-down select input type). 624 * @return (String)handleGetBackingListName() 625 */ 626 public final String getBackingListName() 627 { 628 String backingListName17a = this.__backingListName17a; 629 if (!this.__backingListName17aSet) 630 { 631 // backingListName has no pre constraints 632 backingListName17a = handleGetBackingListName(); 633 // backingListName has no post constraints 634 this.__backingListName17a = backingListName17a; 635 if (isMetafacadePropertyCachingEnabled()) 636 { 637 this.__backingListName17aSet = true; 638 } 639 } 640 return backingListName17a; 641 } 642 643 /** 644 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getLabelListName() 645 * @return String 646 */ 647 protected abstract String handleGetLabelListName(); 648 649 private String __labelListName18a; 650 private boolean __labelListName18aSet = false; 651 652 /** 653 * The name of the label list for this parameter. The label list name is the name of the list 654 * storing the labels for the possible values of this parameter (typically used for the labels 655 * of a drop-down select lists). 656 * @return (String)handleGetLabelListName() 657 */ 658 public final String getLabelListName() 659 { 660 String labelListName18a = this.__labelListName18a; 661 if (!this.__labelListName18aSet) 662 { 663 // labelListName has no pre constraints 664 labelListName18a = handleGetLabelListName(); 665 // labelListName has no post constraints 666 this.__labelListName18a = labelListName18a; 667 if (isMetafacadePropertyCachingEnabled()) 668 { 669 this.__labelListName18aSet = true; 670 } 671 } 672 return labelListName18a; 673 } 674 675 /** 676 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getValueListName() 677 * @return String 678 */ 679 protected abstract String handleGetValueListName(); 680 681 private String __valueListName19a; 682 private boolean __valueListName19aSet = false; 683 684 /** 685 * Stores the name of the value list for this parameter; this list stores the possible values 686 * that this parameter may be (typically used for the values of a drop-down select list). 687 * @return (String)handleGetValueListName() 688 */ 689 public final String getValueListName() 690 { 691 String valueListName19a = this.__valueListName19a; 692 if (!this.__valueListName19aSet) 693 { 694 // valueListName has no pre constraints 695 valueListName19a = handleGetValueListName(); 696 // valueListName has no post constraints 697 this.__valueListName19a = valueListName19a; 698 if (isMetafacadePropertyCachingEnabled()) 699 { 700 this.__valueListName19aSet = true; 701 } 702 } 703 return valueListName19a; 704 } 705 706 /** 707 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isSelectable() 708 * @return boolean 709 */ 710 protected abstract boolean handleIsSelectable(); 711 712 private boolean __selectable20a; 713 private boolean __selectable20aSet = false; 714 715 /** 716 * Indicates whether or not this parameter is selectable or not (that is: it can be selected 717 * from a list of values). 718 * @return (boolean)handleIsSelectable() 719 */ 720 public final boolean isSelectable() 721 { 722 boolean selectable20a = this.__selectable20a; 723 if (!this.__selectable20aSet) 724 { 725 // selectable has no pre constraints 726 selectable20a = handleIsSelectable(); 727 // selectable has no post constraints 728 this.__selectable20a = selectable20a; 729 if (isMetafacadePropertyCachingEnabled()) 730 { 731 this.__selectable20aSet = true; 732 } 733 } 734 return selectable20a; 735 } 736 737 /** 738 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getDummyValue() 739 * @return String 740 */ 741 protected abstract String handleGetDummyValue(); 742 743 private String __dummyValue21a; 744 private boolean __dummyValue21aSet = false; 745 746 /** 747 * The dummy value for this parameter. The dummy value is used for setting the dummy information 748 * when dummyData is enabled. 749 * @return (String)handleGetDummyValue() 750 */ 751 public final String getDummyValue() 752 { 753 String dummyValue21a = this.__dummyValue21a; 754 if (!this.__dummyValue21aSet) 755 { 756 // dummyValue has no pre constraints 757 dummyValue21a = handleGetDummyValue(); 758 // dummyValue has no post constraints 759 this.__dummyValue21a = dummyValue21a; 760 if (isMetafacadePropertyCachingEnabled()) 761 { 762 this.__dummyValue21aSet = true; 763 } 764 } 765 return dummyValue21a; 766 } 767 768 /** 769 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getValueListDummyValue() 770 * @return String 771 */ 772 protected abstract String handleGetValueListDummyValue(); 773 774 private String __valueListDummyValue22a; 775 private boolean __valueListDummyValue22aSet = false; 776 777 /** 778 * The dummy value for a value list. 779 * @return (String)handleGetValueListDummyValue() 780 */ 781 public final String getValueListDummyValue() 782 { 783 String valueListDummyValue22a = this.__valueListDummyValue22a; 784 if (!this.__valueListDummyValue22aSet) 785 { 786 // valueListDummyValue has no pre constraints 787 valueListDummyValue22a = handleGetValueListDummyValue(); 788 // valueListDummyValue has no post constraints 789 this.__valueListDummyValue22a = valueListDummyValue22a; 790 if (isMetafacadePropertyCachingEnabled()) 791 { 792 this.__valueListDummyValue22aSet = true; 793 } 794 } 795 return valueListDummyValue22a; 796 } 797 798 /** 799 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getTableSortColumnProperty() 800 * @return String 801 */ 802 protected abstract String handleGetTableSortColumnProperty(); 803 804 private String __tableSortColumnProperty23a; 805 private boolean __tableSortColumnProperty23aSet = false; 806 807 /** 808 * The name of the property storing the column to sort by if this parameter represents a table. 809 * @return (String)handleGetTableSortColumnProperty() 810 */ 811 public final String getTableSortColumnProperty() 812 { 813 String tableSortColumnProperty23a = this.__tableSortColumnProperty23a; 814 if (!this.__tableSortColumnProperty23aSet) 815 { 816 // tableSortColumnProperty has no pre constraints 817 tableSortColumnProperty23a = handleGetTableSortColumnProperty(); 818 // tableSortColumnProperty has no post constraints 819 this.__tableSortColumnProperty23a = tableSortColumnProperty23a; 820 if (isMetafacadePropertyCachingEnabled()) 821 { 822 this.__tableSortColumnProperty23aSet = true; 823 } 824 } 825 return tableSortColumnProperty23a; 826 } 827 828 /** 829 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getTableSortAscendingProperty() 830 * @return String 831 */ 832 protected abstract String handleGetTableSortAscendingProperty(); 833 834 private String __tableSortAscendingProperty24a; 835 private boolean __tableSortAscendingProperty24aSet = false; 836 837 /** 838 * The name of the property that Indicates whether or not the table should be sorted ascending 839 * (if this parameter represents a table). 840 * @return (String)handleGetTableSortAscendingProperty() 841 */ 842 public final String getTableSortAscendingProperty() 843 { 844 String tableSortAscendingProperty24a = this.__tableSortAscendingProperty24a; 845 if (!this.__tableSortAscendingProperty24aSet) 846 { 847 // tableSortAscendingProperty has no pre constraints 848 tableSortAscendingProperty24a = handleGetTableSortAscendingProperty(); 849 // tableSortAscendingProperty has no post constraints 850 this.__tableSortAscendingProperty24a = tableSortAscendingProperty24a; 851 if (isMetafacadePropertyCachingEnabled()) 852 { 853 this.__tableSortAscendingProperty24aSet = true; 854 } 855 } 856 return tableSortAscendingProperty24a; 857 } 858 859 /** 860 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getFormAttributeSetProperty() 861 * @return String 862 */ 863 protected abstract String handleGetFormAttributeSetProperty(); 864 865 private String __formAttributeSetProperty25a; 866 private boolean __formAttributeSetProperty25aSet = false; 867 868 /** 869 * The name of the property used for indicating whether or not a form attribute has been set at 870 * least once. 871 * @return (String)handleGetFormAttributeSetProperty() 872 */ 873 public final String getFormAttributeSetProperty() 874 { 875 String formAttributeSetProperty25a = this.__formAttributeSetProperty25a; 876 if (!this.__formAttributeSetProperty25aSet) 877 { 878 // formAttributeSetProperty has no pre constraints 879 formAttributeSetProperty25a = handleGetFormAttributeSetProperty(); 880 // formAttributeSetProperty has no post constraints 881 this.__formAttributeSetProperty25a = formAttributeSetProperty25a; 882 if (isMetafacadePropertyCachingEnabled()) 883 { 884 this.__formAttributeSetProperty25aSet = true; 885 } 886 } 887 return formAttributeSetProperty25a; 888 } 889 890 /** 891 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isReadOnly() 892 * @return boolean 893 */ 894 protected abstract boolean handleIsReadOnly(); 895 896 private boolean __readOnly26a; 897 private boolean __readOnly26aSet = false; 898 899 /** 900 * Indicates if this parameter can only be read and not modified. 901 * @return (boolean)handleIsReadOnly() 902 */ 903 public final boolean isReadOnly() 904 { 905 boolean readOnly26a = this.__readOnly26a; 906 if (!this.__readOnly26aSet) 907 { 908 // readOnly has no pre constraints 909 readOnly26a = handleIsReadOnly(); 910 // readOnly has no post constraints 911 this.__readOnly26a = readOnly26a; 912 if (isMetafacadePropertyCachingEnabled()) 913 { 914 this.__readOnly26aSet = true; 915 } 916 } 917 return readOnly26a; 918 } 919 920 /** 921 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isValidationRequired() 922 * @return boolean 923 */ 924 protected abstract boolean handleIsValidationRequired(); 925 926 private boolean __validationRequired27a; 927 private boolean __validationRequired27aSet = false; 928 929 /** 930 * Indicates whether or not this parameter requires some kind of validation (the collection of 931 * validator types is not empty). 932 * @return (boolean)handleIsValidationRequired() 933 */ 934 public final boolean isValidationRequired() 935 { 936 boolean validationRequired27a = this.__validationRequired27a; 937 if (!this.__validationRequired27aSet) 938 { 939 // validationRequired has no pre constraints 940 validationRequired27a = handleIsValidationRequired(); 941 // validationRequired has no post constraints 942 this.__validationRequired27a = validationRequired27a; 943 if (isMetafacadePropertyCachingEnabled()) 944 { 945 this.__validationRequired27aSet = true; 946 } 947 } 948 return validationRequired27a; 949 } 950 951 /** 952 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getValidatorTypes() 953 * @return Collection 954 */ 955 protected abstract Collection handleGetValidatorTypes(); 956 957 private Collection __validatorTypes28a; 958 private boolean __validatorTypes28aSet = false; 959 960 /** 961 * All the validator types for this parameter. 962 * @return (Collection)handleGetValidatorTypes() 963 */ 964 public final Collection getValidatorTypes() 965 { 966 Collection validatorTypes28a = this.__validatorTypes28a; 967 if (!this.__validatorTypes28aSet) 968 { 969 // validatorTypes has no pre constraints 970 validatorTypes28a = handleGetValidatorTypes(); 971 // validatorTypes has no post constraints 972 this.__validatorTypes28a = validatorTypes28a; 973 if (isMetafacadePropertyCachingEnabled()) 974 { 975 this.__validatorTypes28aSet = true; 976 } 977 } 978 return validatorTypes28a; 979 } 980 981 /** 982 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getValidWhen() 983 * @return String 984 */ 985 protected abstract String handleGetValidWhen(); 986 987 private String __validWhen29a; 988 private boolean __validWhen29aSet = false; 989 990 /** 991 * The validator's 'validwhen' value, this is useful when the validation of a parameter depends 992 * on the validation of others. See the apache commons-validator documentation for more 993 * information. 994 * @return (String)handleGetValidWhen() 995 */ 996 public final String getValidWhen() 997 { 998 String validWhen29a = this.__validWhen29a; 999 if (!this.__validWhen29aSet) 1000 { 1001 // validWhen has no pre constraints 1002 validWhen29a = handleGetValidWhen(); 1003 // validWhen has no post constraints 1004 this.__validWhen29a = validWhen29a; 1005 if (isMetafacadePropertyCachingEnabled()) 1006 { 1007 this.__validWhen29aSet = true; 1008 } 1009 } 1010 return validWhen29a; 1011 } 1012 1013 /** 1014 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isInputFile() 1015 * @return boolean 1016 */ 1017 protected abstract boolean handleIsInputFile(); 1018 1019 private boolean __inputFile30a; 1020 private boolean __inputFile30aSet = false; 1021 1022 /** 1023 * Indicates whether or not this is a file input type. 1024 * @return (boolean)handleIsInputFile() 1025 */ 1026 public final boolean isInputFile() 1027 { 1028 boolean inputFile30a = this.__inputFile30a; 1029 if (!this.__inputFile30aSet) 1030 { 1031 // inputFile has no pre constraints 1032 inputFile30a = handleIsInputFile(); 1033 // inputFile has no post constraints 1034 this.__inputFile30a = inputFile30a; 1035 if (isMetafacadePropertyCachingEnabled()) 1036 { 1037 this.__inputFile30aSet = true; 1038 } 1039 } 1040 return inputFile30a; 1041 } 1042 1043 /** 1044 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getValidatorVars() 1045 * @return Collection 1046 */ 1047 protected abstract Collection handleGetValidatorVars(); 1048 1049 private Collection __validatorVars31a; 1050 private boolean __validatorVars31aSet = false; 1051 1052 /** 1053 * The validator variables. 1054 * @return (Collection)handleGetValidatorVars() 1055 */ 1056 public final Collection getValidatorVars() 1057 { 1058 Collection validatorVars31a = this.__validatorVars31a; 1059 if (!this.__validatorVars31aSet) 1060 { 1061 // validatorVars has no pre constraints 1062 validatorVars31a = handleGetValidatorVars(); 1063 // validatorVars has no post constraints 1064 this.__validatorVars31a = validatorVars31a; 1065 if (isMetafacadePropertyCachingEnabled()) 1066 { 1067 this.__validatorVars31aSet = true; 1068 } 1069 } 1070 return validatorVars31a; 1071 } 1072 1073 /** 1074 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isInputMultibox() 1075 * @return boolean 1076 */ 1077 protected abstract boolean handleIsInputMultibox(); 1078 1079 private boolean __inputMultibox32a; 1080 private boolean __inputMultibox32aSet = false; 1081 1082 /** 1083 * Indicates whether or not this type represents an input multibox. 1084 * @return (boolean)handleIsInputMultibox() 1085 */ 1086 public final boolean isInputMultibox() 1087 { 1088 boolean inputMultibox32a = this.__inputMultibox32a; 1089 if (!this.__inputMultibox32aSet) 1090 { 1091 // inputMultibox has no pre constraints 1092 inputMultibox32a = handleIsInputMultibox(); 1093 // inputMultibox has no post constraints 1094 this.__inputMultibox32a = inputMultibox32a; 1095 if (isMetafacadePropertyCachingEnabled()) 1096 { 1097 this.__inputMultibox32aSet = true; 1098 } 1099 } 1100 return inputMultibox32a; 1101 } 1102 1103 /** 1104 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isReset() 1105 * @return boolean 1106 */ 1107 protected abstract boolean handleIsReset(); 1108 1109 private boolean __reset33a; 1110 private boolean __reset33aSet = false; 1111 1112 /** 1113 * Indicates if this parameter's value should be reset or not after an action has been performed 1114 * with this parameter. 1115 * @return (boolean)handleIsReset() 1116 */ 1117 public final boolean isReset() 1118 { 1119 boolean reset33a = this.__reset33a; 1120 if (!this.__reset33aSet) 1121 { 1122 // reset has no pre constraints 1123 reset33a = handleIsReset(); 1124 // reset has no post constraints 1125 this.__reset33a = reset33a; 1126 if (isMetafacadePropertyCachingEnabled()) 1127 { 1128 this.__reset33aSet = true; 1129 } 1130 } 1131 return reset33a; 1132 } 1133 1134 /** 1135 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isComplex() 1136 * @return boolean 1137 */ 1138 protected abstract boolean handleIsComplex(); 1139 1140 private boolean __complex34a; 1141 private boolean __complex34aSet = false; 1142 1143 /** 1144 * Indicates if this parameter is 'complex', that is: its of a complex type (has at least one 1145 * attribute or association). 1146 * @return (boolean)handleIsComplex() 1147 */ 1148 public final boolean isComplex() 1149 { 1150 boolean complex34a = this.__complex34a; 1151 if (!this.__complex34aSet) 1152 { 1153 // complex has no pre constraints 1154 complex34a = handleIsComplex(); 1155 // complex has no post constraints 1156 this.__complex34a = complex34a; 1157 if (isMetafacadePropertyCachingEnabled()) 1158 { 1159 this.__complex34aSet = true; 1160 } 1161 } 1162 return complex34a; 1163 } 1164 1165 /** 1166 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getAttributes() 1167 * @return Collection 1168 */ 1169 protected abstract Collection handleGetAttributes(); 1170 1171 private Collection __attributes35a; 1172 private boolean __attributes35aSet = false; 1173 1174 /** 1175 * All attributes belonging to this parameter's type. 1176 * @return (Collection)handleGetAttributes() 1177 */ 1178 public final Collection getAttributes() 1179 { 1180 Collection attributes35a = this.__attributes35a; 1181 if (!this.__attributes35aSet) 1182 { 1183 // attributes has no pre constraints 1184 attributes35a = handleGetAttributes(); 1185 // attributes has no post constraints 1186 this.__attributes35a = attributes35a; 1187 if (isMetafacadePropertyCachingEnabled()) 1188 { 1189 this.__attributes35aSet = true; 1190 } 1191 } 1192 return attributes35a; 1193 } 1194 1195 /** 1196 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getNavigableAssociationEnds() 1197 * @return Collection 1198 */ 1199 protected abstract Collection handleGetNavigableAssociationEnds(); 1200 1201 private Collection __navigableAssociationEnds36a; 1202 private boolean __navigableAssociationEnds36aSet = false; 1203 1204 /** 1205 * All navigation association ends belonging to this parameter's type. 1206 * @return (Collection)handleGetNavigableAssociationEnds() 1207 */ 1208 public final Collection getNavigableAssociationEnds() 1209 { 1210 Collection navigableAssociationEnds36a = this.__navigableAssociationEnds36a; 1211 if (!this.__navigableAssociationEnds36aSet) 1212 { 1213 // navigableAssociationEnds has no pre constraints 1214 navigableAssociationEnds36a = handleGetNavigableAssociationEnds(); 1215 // navigableAssociationEnds has no post constraints 1216 this.__navigableAssociationEnds36a = navigableAssociationEnds36a; 1217 if (isMetafacadePropertyCachingEnabled()) 1218 { 1219 this.__navigableAssociationEnds36aSet = true; 1220 } 1221 } 1222 return navigableAssociationEnds36a; 1223 } 1224 1225 /** 1226 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isEqualValidator() 1227 * @return boolean 1228 */ 1229 protected abstract boolean handleIsEqualValidator(); 1230 1231 private boolean __equalValidator37a; 1232 private boolean __equalValidator37aSet = false; 1233 1234 /** 1235 * Indicates whether or not this parameter uses the equal validator. 1236 * @return (boolean)handleIsEqualValidator() 1237 */ 1238 public final boolean isEqualValidator() 1239 { 1240 boolean equalValidator37a = this.__equalValidator37a; 1241 if (!this.__equalValidator37aSet) 1242 { 1243 // equalValidator has no pre constraints 1244 equalValidator37a = handleIsEqualValidator(); 1245 // equalValidator has no post constraints 1246 this.__equalValidator37a = equalValidator37a; 1247 if (isMetafacadePropertyCachingEnabled()) 1248 { 1249 this.__equalValidator37aSet = true; 1250 } 1251 } 1252 return equalValidator37a; 1253 } 1254 1255 /** 1256 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getBackingValueName() 1257 * @return String 1258 */ 1259 protected abstract String handleGetBackingValueName(); 1260 1261 private String __backingValueName38a; 1262 private boolean __backingValueName38aSet = false; 1263 1264 /** 1265 * The name of the backing value for this parameter (only used with collections and arrays that 1266 * are input type table). 1267 * @return (String)handleGetBackingValueName() 1268 */ 1269 public final String getBackingValueName() 1270 { 1271 String backingValueName38a = this.__backingValueName38a; 1272 if (!this.__backingValueName38aSet) 1273 { 1274 // backingValueName has no pre constraints 1275 backingValueName38a = handleGetBackingValueName(); 1276 // backingValueName has no post constraints 1277 this.__backingValueName38a = backingValueName38a; 1278 if (isMetafacadePropertyCachingEnabled()) 1279 { 1280 this.__backingValueName38aSet = true; 1281 } 1282 } 1283 return backingValueName38a; 1284 } 1285 1286 /** 1287 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isInputTable() 1288 * @return boolean 1289 */ 1290 protected abstract boolean handleIsInputTable(); 1291 1292 private boolean __inputTable39a; 1293 private boolean __inputTable39aSet = false; 1294 1295 /** 1296 * Indicates whether or not this is an table input type. 1297 * @return (boolean)handleIsInputTable() 1298 */ 1299 public final boolean isInputTable() 1300 { 1301 boolean inputTable39a = this.__inputTable39a; 1302 if (!this.__inputTable39aSet) 1303 { 1304 // inputTable has no pre constraints 1305 inputTable39a = handleIsInputTable(); 1306 // inputTable has no post constraints 1307 this.__inputTable39a = inputTable39a; 1308 if (isMetafacadePropertyCachingEnabled()) 1309 { 1310 this.__inputTable39aSet = true; 1311 } 1312 } 1313 return inputTable39a; 1314 } 1315 1316 /** 1317 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isBackingValueRequired() 1318 * @return boolean 1319 */ 1320 protected abstract boolean handleIsBackingValueRequired(); 1321 1322 private boolean __backingValueRequired40a; 1323 private boolean __backingValueRequired40aSet = false; 1324 1325 /** 1326 * Indicates if a backing value is required for this parameter. 1327 * @return (boolean)handleIsBackingValueRequired() 1328 */ 1329 public final boolean isBackingValueRequired() 1330 { 1331 boolean backingValueRequired40a = this.__backingValueRequired40a; 1332 if (!this.__backingValueRequired40aSet) 1333 { 1334 // backingValueRequired has no pre constraints 1335 backingValueRequired40a = handleIsBackingValueRequired(); 1336 // backingValueRequired has no post constraints 1337 this.__backingValueRequired40a = backingValueRequired40a; 1338 if (isMetafacadePropertyCachingEnabled()) 1339 { 1340 this.__backingValueRequired40aSet = true; 1341 } 1342 } 1343 return backingValueRequired40a; 1344 } 1345 1346 /** 1347 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getInputTableIdentifierColumns() 1348 * @return String 1349 */ 1350 protected abstract String handleGetInputTableIdentifierColumns(); 1351 1352 private String __inputTableIdentifierColumns41a; 1353 private boolean __inputTableIdentifierColumns41aSet = false; 1354 1355 /** 1356 * A comma separated list of the input table identifier columns (these are the columns that 1357 * uniquely define a row in an input table). 1358 * @return (String)handleGetInputTableIdentifierColumns() 1359 */ 1360 public final String getInputTableIdentifierColumns() 1361 { 1362 String inputTableIdentifierColumns41a = this.__inputTableIdentifierColumns41a; 1363 if (!this.__inputTableIdentifierColumns41aSet) 1364 { 1365 // inputTableIdentifierColumns has no pre constraints 1366 inputTableIdentifierColumns41a = handleGetInputTableIdentifierColumns(); 1367 // inputTableIdentifierColumns has no post constraints 1368 this.__inputTableIdentifierColumns41a = inputTableIdentifierColumns41a; 1369 if (isMetafacadePropertyCachingEnabled()) 1370 { 1371 this.__inputTableIdentifierColumns41aSet = true; 1372 } 1373 } 1374 return inputTableIdentifierColumns41a; 1375 } 1376 1377 /** 1378 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#isPageableTable() 1379 * @return boolean 1380 */ 1381 protected abstract boolean handleIsPageableTable(); 1382 1383 private boolean __pageableTable42a; 1384 private boolean __pageableTable42aSet = false; 1385 1386 /** 1387 * Whether or not the parameter is a "pageable table", that is a table that supports paging 1388 * (i.e. DB paging). 1389 * @return (boolean)handleIsPageableTable() 1390 */ 1391 public final boolean isPageableTable() 1392 { 1393 boolean pageableTable42a = this.__pageableTable42a; 1394 if (!this.__pageableTable42aSet) 1395 { 1396 // pageableTable has no pre constraints 1397 pageableTable42a = handleIsPageableTable(); 1398 // pageableTable has no post constraints 1399 this.__pageableTable42a = pageableTable42a; 1400 if (isMetafacadePropertyCachingEnabled()) 1401 { 1402 this.__pageableTable42aSet = true; 1403 } 1404 } 1405 return pageableTable42a; 1406 } 1407 1408 /** 1409 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getMaxLength() 1410 * @return String 1411 */ 1412 protected abstract String handleGetMaxLength(); 1413 1414 private String __maxLength43a; 1415 private boolean __maxLength43aSet = false; 1416 1417 /** 1418 * The max length allowed in the input component 1419 * @return (String)handleGetMaxLength() 1420 */ 1421 public final String getMaxLength() 1422 { 1423 String maxLength43a = this.__maxLength43a; 1424 if (!this.__maxLength43aSet) 1425 { 1426 // maxLength has no pre constraints 1427 maxLength43a = handleGetMaxLength(); 1428 // maxLength has no post constraints 1429 this.__maxLength43a = maxLength43a; 1430 if (isMetafacadePropertyCachingEnabled()) 1431 { 1432 this.__maxLength43aSet = true; 1433 } 1434 } 1435 return maxLength43a; 1436 } 1437 1438 /** 1439 * @see org.andromda.cartridges.jsf.metafacades.JSFParameter#getAnnotations() 1440 * @return Collection 1441 */ 1442 protected abstract Collection handleGetAnnotations(); 1443 1444 private Collection __annotations44a; 1445 private boolean __annotations44aSet = false; 1446 1447 /** 1448 * All the annotations for this parameter. 1449 * @return (Collection)handleGetAnnotations() 1450 */ 1451 public final Collection getAnnotations() 1452 { 1453 Collection annotations44a = this.__annotations44a; 1454 if (!this.__annotations44aSet) 1455 { 1456 // annotations has no pre constraints 1457 annotations44a = handleGetAnnotations(); 1458 // annotations has no post constraints 1459 this.__annotations44a = annotations44a; 1460 if (isMetafacadePropertyCachingEnabled()) 1461 { 1462 this.__annotations44aSet = true; 1463 } 1464 } 1465 return annotations44a; 1466 } 1467 1468 // ---------------- business methods ---------------------- 1469 1470 /** 1471 * Method to be implemented in descendants 1472 * TODO: Model Documentation for 1473 * org.andromda.cartridges.jsf.metafacades.JSFParameter.getTableColumnMessageKey 1474 * @param columnName 1475 * @return String 1476 */ 1477 protected abstract String handleGetTableColumnMessageKey(String columnName); 1478 1479 /** 1480 * TODO: Model Documentation for 1481 * org.andromda.cartridges.jsf.metafacades.JSFParameter.getTableColumnMessageKey 1482 * @param columnName String 1483 * The name of the table column. 1484 * @return handleGetTableColumnMessageKey(columnName) 1485 */ 1486 public String getTableColumnMessageKey(String columnName) 1487 { 1488 // getTableColumnMessageKey has no pre constraints 1489 String returnValue = handleGetTableColumnMessageKey(columnName); 1490 // getTableColumnMessageKey has no post constraints 1491 return returnValue; 1492 } 1493 1494 /** 1495 * Method to be implemented in descendants 1496 * TODO: Model Documentation for 1497 * org.andromda.cartridges.jsf.metafacades.JSFParameter.getTableColumnMessageValue 1498 * @param columnName 1499 * @return String 1500 */ 1501 protected abstract String handleGetTableColumnMessageValue(String columnName); 1502 1503 /** 1504 * TODO: Model Documentation for 1505 * org.andromda.cartridges.jsf.metafacades.JSFParameter.getTableColumnMessageValue 1506 * @param columnName String 1507 * Returns the resource bundle value for this table's column, only returns a value when this 1508 * parameter is a table. 1509 * @return handleGetTableColumnMessageValue(columnName) 1510 */ 1511 public String getTableColumnMessageValue(String columnName) 1512 { 1513 // getTableColumnMessageValue has no pre constraints 1514 String returnValue = handleGetTableColumnMessageValue(columnName); 1515 // getTableColumnMessageValue has no post constraints 1516 return returnValue; 1517 } 1518 1519 /** 1520 * Method to be implemented in descendants 1521 * Gets the arguments for this parameter's validators. 1522 * @param validatorType 1523 * @return Collection 1524 */ 1525 protected abstract Collection handleGetValidatorArgs(String validatorType); 1526 1527 /** 1528 * Gets the arguments for this parameter's validators. 1529 * @param validatorType String 1530 * The type of the validator. 1531 * @return handleGetValidatorArgs(validatorType) 1532 */ 1533 public Collection getValidatorArgs(String validatorType) 1534 { 1535 // getValidatorArgs has no pre constraints 1536 Collection returnValue = handleGetValidatorArgs(validatorType); 1537 // getValidatorArgs has no post constraints 1538 return returnValue; 1539 } 1540 1541 /** 1542 * Method to be implemented in descendants 1543 * Those actions that are targetting the given column, only makes sense when this parameter 1544 * represents a table view-variable. 1545 * @param columnName 1546 * @return List 1547 */ 1548 protected abstract List handleGetTableColumnActions(String columnName); 1549 1550 /** 1551 * Those actions that are targetting the given column, only makes sense when this parameter 1552 * represents a table view-variable. 1553 * @param columnName String 1554 * The column name of the column that the retrieved actions target. 1555 * @return handleGetTableColumnActions(columnName) 1556 */ 1557 public List getTableColumnActions(String columnName) 1558 { 1559 // getTableColumnActions has no pre constraints 1560 List returnValue = handleGetTableColumnActions(columnName); 1561 // getTableColumnActions has no post constraints 1562 return returnValue; 1563 } 1564 1565 // ------------- associations ------------------ 1566 1567 private List<JSFAction> __getTableHyperlinkActions1r; 1568 private boolean __getTableHyperlinkActions1rSet = false; 1569 1570 /** 1571 * Represents a parameter in a JSF front-end. 1572 * @return (List<JSFAction>)handleGetTableHyperlinkActions() 1573 */ 1574 public final List<JSFAction> getTableHyperlinkActions() 1575 { 1576 List<JSFAction> getTableHyperlinkActions1r = this.__getTableHyperlinkActions1r; 1577 if (!this.__getTableHyperlinkActions1rSet) 1578 { 1579 // jSFParameter has no pre constraints 1580 List result = handleGetTableHyperlinkActions(); 1581 List shieldedResult = this.shieldedElements(result); 1582 try 1583 { 1584 getTableHyperlinkActions1r = (List<JSFAction>)shieldedResult; 1585 } 1586 catch (ClassCastException ex) 1587 { 1588 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1589 JSFParameterLogic.logger.warn("incorrect metafacade cast for JSFParameterLogic.getTableHyperlinkActions List<JSFAction> " + result + ": " + shieldedResult); 1590 } 1591 // jSFParameter has no post constraints 1592 this.__getTableHyperlinkActions1r = getTableHyperlinkActions1r; 1593 if (isMetafacadePropertyCachingEnabled()) 1594 { 1595 this.__getTableHyperlinkActions1rSet = true; 1596 } 1597 } 1598 return getTableHyperlinkActions1r; 1599 } 1600 1601 /** 1602 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type 1603 * @return List 1604 */ 1605 protected abstract List handleGetTableHyperlinkActions(); 1606 1607 private List<JSFAction> __getTableFormActions2r; 1608 private boolean __getTableFormActions2rSet = false; 1609 1610 /** 1611 * Represents a parameter in a JSF front-end. 1612 * @return (List<JSFAction>)handleGetTableFormActions() 1613 */ 1614 public final List<JSFAction> getTableFormActions() 1615 { 1616 List<JSFAction> getTableFormActions2r = this.__getTableFormActions2r; 1617 if (!this.__getTableFormActions2rSet) 1618 { 1619 // jSFParameter has no pre constraints 1620 List result = handleGetTableFormActions(); 1621 List shieldedResult = this.shieldedElements(result); 1622 try 1623 { 1624 getTableFormActions2r = (List<JSFAction>)shieldedResult; 1625 } 1626 catch (ClassCastException ex) 1627 { 1628 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1629 JSFParameterLogic.logger.warn("incorrect metafacade cast for JSFParameterLogic.getTableFormActions List<JSFAction> " + result + ": " + shieldedResult); 1630 } 1631 // jSFParameter has no post constraints 1632 this.__getTableFormActions2r = getTableFormActions2r; 1633 if (isMetafacadePropertyCachingEnabled()) 1634 { 1635 this.__getTableFormActions2rSet = true; 1636 } 1637 } 1638 return getTableFormActions2r; 1639 } 1640 1641 /** 1642 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type 1643 * @return List 1644 */ 1645 protected abstract List handleGetTableFormActions(); 1646 1647 /** 1648 * @return true 1649 * @see FrontEndParameter 1650 */ 1651 public boolean isFrontEndParameterMetaType() 1652 { 1653 return true; 1654 } 1655 1656 /** 1657 * @return true 1658 * @see org.andromda.metafacades.uml.ParameterFacade 1659 */ 1660 public boolean isParameterFacadeMetaType() 1661 { 1662 return true; 1663 } 1664 1665 /** 1666 * @return true 1667 * @see ModelElementFacade 1668 */ 1669 public boolean isModelElementFacadeMetaType() 1670 { 1671 return true; 1672 } 1673 1674 // ----------- delegates to FrontEndParameter ------------ 1675 /** 1676 * The action to which this parameter belongs (if it belongs to an action), otherwise it returns 1677 * null. 1678 * @see FrontEndParameter#getAction() 1679 */ 1680 public FrontEndAction getAction() 1681 { 1682 return this.getSuperFrontEndParameter().getAction(); 1683 } 1684 1685 /** 1686 * Gets the controller operation to which this parameter belongs. 1687 * @see FrontEndParameter#getControllerOperation() 1688 */ 1689 public FrontEndControllerOperation getControllerOperation() 1690 { 1691 return this.getSuperFrontEndParameter().getControllerOperation(); 1692 } 1693 1694 /** 1695 * A collection of all possible attribute names of a table (this will only work when your table 1696 * is modeled as an array..not a collection). 1697 * @see FrontEndParameter#getTableAttributeNames() 1698 */ 1699 public Collection<String> getTableAttributeNames() 1700 { 1701 return this.getSuperFrontEndParameter().getTableAttributeNames(); 1702 } 1703 1704 /** 1705 * All the columns for this parameter if it represents a table variable. If a column is linked 1706 * by an event (action) a FrontEndParameter instance is included in the return value, otherwise 1707 * a plain String representing the column name. 1708 * @see FrontEndParameter#getTableColumnNames() 1709 */ 1710 public Collection<String> getTableColumnNames() 1711 { 1712 return this.getSuperFrontEndParameter().getTableColumnNames(); 1713 } 1714 1715 /** 1716 * A list of all attributes which make up the table columns of this table (this only contains 1717 * attributes when the table is represented by an array). 1718 * @see FrontEndParameter#getTableColumns() 1719 */ 1720 public Collection<String> getTableColumns() 1721 { 1722 return this.getSuperFrontEndParameter().getTableColumns(); 1723 } 1724 1725 /** 1726 * Represents the view in which this parameter will be used. 1727 * @see FrontEndParameter#getView() 1728 */ 1729 public FrontEndView getView() 1730 { 1731 return this.getSuperFrontEndParameter().getView(); 1732 } 1733 1734 /** 1735 * Indicates whether or not this is an action parameter or not. 1736 * @see FrontEndParameter#isActionParameter() 1737 */ 1738 public boolean isActionParameter() 1739 { 1740 return this.getSuperFrontEndParameter().isActionParameter(); 1741 } 1742 1743 /** 1744 * Indicates if this parameter is contained in a "front-end" use case. 1745 * @see FrontEndParameter#isContainedInFrontEndUseCase() 1746 */ 1747 public boolean isContainedInFrontEndUseCase() 1748 { 1749 return this.getSuperFrontEndParameter().isContainedInFrontEndUseCase(); 1750 } 1751 1752 /** 1753 * Indicates whether or not this parameter is an argument of a controller operation. 1754 * @see FrontEndParameter#isControllerOperationArgument() 1755 */ 1756 public boolean isControllerOperationArgument() 1757 { 1758 return this.getSuperFrontEndParameter().isControllerOperationArgument(); 1759 } 1760 1761 /** 1762 * Indicates whether or not this parameter represents a table. 1763 * @see FrontEndParameter#isTable() 1764 */ 1765 public boolean isTable() 1766 { 1767 return this.getSuperFrontEndParameter().isTable(); 1768 } 1769 1770 /** 1771 * Copies all tagged values from the given ModelElementFacade to this model element facade. 1772 * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element) 1773 */ 1774 public void copyTaggedValues(ModelElementFacade element) 1775 { 1776 this.getSuperFrontEndParameter().copyTaggedValues(element); 1777 } 1778 1779 /** 1780 * Finds the tagged value with the specified 'tagName'. In case there are more values the first 1781 * one found will be returned. 1782 * @see ModelElementFacade#findTaggedValue(String tagName) 1783 */ 1784 public Object findTaggedValue(String tagName) 1785 { 1786 return this.getSuperFrontEndParameter().findTaggedValue(tagName); 1787 } 1788 1789 /** 1790 * Returns all the values for the tagged value with the specified name. The returned collection 1791 * will contains only String instances, or will be empty. Never null. 1792 * @see ModelElementFacade#findTaggedValues(String tagName) 1793 */ 1794 public Collection<Object> findTaggedValues(String tagName) 1795 { 1796 return this.getSuperFrontEndParameter().findTaggedValues(tagName); 1797 } 1798 1799 /** 1800 * Returns the fully qualified name of the model element. The fully qualified name includes 1801 * complete package qualified name of the underlying model element. The templates parameter will 1802 * be replaced by the correct one given the binding relation of the parameter to this element. 1803 * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement) 1804 */ 1805 public String getBindedFullyQualifiedName(ModelElementFacade bindedElement) 1806 { 1807 return this.getSuperFrontEndParameter().getBindedFullyQualifiedName(bindedElement); 1808 } 1809 1810 /** 1811 * Gets all constraints belonging to the model element. 1812 * @see ModelElementFacade#getConstraints() 1813 */ 1814 public Collection<ConstraintFacade> getConstraints() 1815 { 1816 return this.getSuperFrontEndParameter().getConstraints(); 1817 } 1818 1819 /** 1820 * Returns the constraints of the argument kind that have been placed onto this model. Typical 1821 * kinds are "inv", "pre" and "post". Other kinds are possible. 1822 * @see ModelElementFacade#getConstraints(String kind) 1823 */ 1824 public Collection<ConstraintFacade> getConstraints(String kind) 1825 { 1826 return this.getSuperFrontEndParameter().getConstraints(kind); 1827 } 1828 1829 /** 1830 * Gets the documentation for the model element, The indent argument is prefixed to each line. 1831 * By default this method wraps lines after 64 characters. 1832 * This method is equivalent to <code>getDocumentation(indent, 64)</code>. 1833 * @see ModelElementFacade#getDocumentation(String indent) 1834 */ 1835 public String getDocumentation(String indent) 1836 { 1837 return this.getSuperFrontEndParameter().getDocumentation(indent); 1838 } 1839 1840 /** 1841 * This method returns the documentation for this model element, with the lines wrapped after 1842 * the specified number of characters, values of less than 1 will indicate no line wrapping is 1843 * required. By default paragraphs are returned as HTML. 1844 * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>. 1845 * @see ModelElementFacade#getDocumentation(String indent, int lineLength) 1846 */ 1847 public String getDocumentation(String indent, int lineLength) 1848 { 1849 return this.getSuperFrontEndParameter().getDocumentation(indent, lineLength); 1850 } 1851 1852 /** 1853 * This method returns the documentation for this model element, with the lines wrapped after 1854 * the specified number of characters, values of less than 1 will indicate no line wrapping is 1855 * required. HTML style determines if HTML Escaping is applied. 1856 * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle) 1857 */ 1858 public String getDocumentation(String indent, int lineLength, boolean htmlStyle) 1859 { 1860 return this.getSuperFrontEndParameter().getDocumentation(indent, lineLength, htmlStyle); 1861 } 1862 1863 /** 1864 * The fully qualified name of this model element. 1865 * @see ModelElementFacade#getFullyQualifiedName() 1866 */ 1867 public String getFullyQualifiedName() 1868 { 1869 return this.getSuperFrontEndParameter().getFullyQualifiedName(); 1870 } 1871 1872 /** 1873 * Returns the fully qualified name of the model element. The fully qualified name includes 1874 * complete package qualified name of the underlying model element. If modelName is true, then 1875 * the original name of the model element (the name contained within the model) will be the name 1876 * returned, otherwise a name from a language mapping will be returned. 1877 * @see ModelElementFacade#getFullyQualifiedName(boolean modelName) 1878 */ 1879 public String getFullyQualifiedName(boolean modelName) 1880 { 1881 return this.getSuperFrontEndParameter().getFullyQualifiedName(modelName); 1882 } 1883 1884 /** 1885 * Returns the fully qualified name as a path, the returned value always starts with out a slash 1886 * '/'. 1887 * @see ModelElementFacade#getFullyQualifiedNamePath() 1888 */ 1889 public String getFullyQualifiedNamePath() 1890 { 1891 return this.getSuperFrontEndParameter().getFullyQualifiedNamePath(); 1892 } 1893 1894 /** 1895 * Gets the unique identifier of the underlying model element. 1896 * @see ModelElementFacade#getId() 1897 */ 1898 public String getId() 1899 { 1900 return this.getSuperFrontEndParameter().getId(); 1901 } 1902 1903 /** 1904 * UML2: Retrieves the keywords for this element. Used to modify implementation properties which 1905 * are not represented by other properties, i.e. native, transient, volatile, synchronized, 1906 * (added annotations) override, deprecated. Can also be used to suppress compiler warnings: 1907 * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require 1908 * JDK5 compiler level. 1909 * @see ModelElementFacade#getKeywords() 1910 */ 1911 public Collection<String> getKeywords() 1912 { 1913 return this.getSuperFrontEndParameter().getKeywords(); 1914 } 1915 1916 /** 1917 * UML2: Retrieves a localized label for this named element. 1918 * @see ModelElementFacade#getLabel() 1919 */ 1920 public String getLabel() 1921 { 1922 return this.getSuperFrontEndParameter().getLabel(); 1923 } 1924 1925 /** 1926 * The language mappings that have been set for this model element. 1927 * @see ModelElementFacade#getLanguageMappings() 1928 */ 1929 public TypeMappings getLanguageMappings() 1930 { 1931 return this.getSuperFrontEndParameter().getLanguageMappings(); 1932 } 1933 1934 /** 1935 * Return the model containing this model element (multiple models may be loaded and processed 1936 * at the same time). 1937 * @see ModelElementFacade#getModel() 1938 */ 1939 public ModelFacade getModel() 1940 { 1941 return this.getSuperFrontEndParameter().getModel(); 1942 } 1943 1944 /** 1945 * The name of the model element. 1946 * @see ModelElementFacade#getName() 1947 */ 1948 public String getName() 1949 { 1950 return this.getSuperFrontEndParameter().getName(); 1951 } 1952 1953 /** 1954 * Gets the package to which this model element belongs. 1955 * @see ModelElementFacade#getPackage() 1956 */ 1957 public ModelElementFacade getPackage() 1958 { 1959 return this.getSuperFrontEndParameter().getPackage(); 1960 } 1961 1962 /** 1963 * The name of this model element's package. 1964 * @see ModelElementFacade#getPackageName() 1965 */ 1966 public String getPackageName() 1967 { 1968 return this.getSuperFrontEndParameter().getPackageName(); 1969 } 1970 1971 /** 1972 * Gets the package name (optionally providing the ability to retrieve the model name and not 1973 * the mapped name). 1974 * @see ModelElementFacade#getPackageName(boolean modelName) 1975 */ 1976 public String getPackageName(boolean modelName) 1977 { 1978 return this.getSuperFrontEndParameter().getPackageName(modelName); 1979 } 1980 1981 /** 1982 * Returns the package as a path, the returned value always starts with out a slash '/'. 1983 * @see ModelElementFacade#getPackagePath() 1984 */ 1985 public String getPackagePath() 1986 { 1987 return this.getSuperFrontEndParameter().getPackagePath(); 1988 } 1989 1990 /** 1991 * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the 1992 * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from 1993 * the names of the containing namespaces starting at the root of the hierarchy and ending with 1994 * the name of the NamedElement itself. 1995 * @see ModelElementFacade#getQualifiedName() 1996 */ 1997 public String getQualifiedName() 1998 { 1999 return this.getSuperFrontEndParameter().getQualifiedName(); 2000 } 2001 2002 /** 2003 * Gets the root package for the model element. 2004 * @see ModelElementFacade#getRootPackage() 2005 */ 2006 public PackageFacade getRootPackage() 2007 { 2008 return this.getSuperFrontEndParameter().getRootPackage(); 2009 } 2010 2011 /** 2012 * Gets the dependencies for which this model element is the source. 2013 * @see ModelElementFacade#getSourceDependencies() 2014 */ 2015 public Collection<DependencyFacade> getSourceDependencies() 2016 { 2017 return this.getSuperFrontEndParameter().getSourceDependencies(); 2018 } 2019 2020 /** 2021 * If this model element is the context of an activity graph, this represents that activity 2022 * graph. 2023 * @see ModelElementFacade#getStateMachineContext() 2024 */ 2025 public StateMachineFacade getStateMachineContext() 2026 { 2027 return this.getSuperFrontEndParameter().getStateMachineContext(); 2028 } 2029 2030 /** 2031 * The collection of ALL stereotype names for this model element. 2032 * @see ModelElementFacade#getStereotypeNames() 2033 */ 2034 public Collection<String> getStereotypeNames() 2035 { 2036 return this.getSuperFrontEndParameter().getStereotypeNames(); 2037 } 2038 2039 /** 2040 * Gets all stereotypes for this model element. 2041 * @see ModelElementFacade#getStereotypes() 2042 */ 2043 public Collection<StereotypeFacade> getStereotypes() 2044 { 2045 return this.getSuperFrontEndParameter().getStereotypes(); 2046 } 2047 2048 /** 2049 * Return the TaggedValues associated with this model element, under all stereotypes. 2050 * @see ModelElementFacade#getTaggedValues() 2051 */ 2052 public Collection<TaggedValueFacade> getTaggedValues() 2053 { 2054 return this.getSuperFrontEndParameter().getTaggedValues(); 2055 } 2056 2057 /** 2058 * Gets the dependencies for which this model element is the target. 2059 * @see ModelElementFacade#getTargetDependencies() 2060 */ 2061 public Collection<DependencyFacade> getTargetDependencies() 2062 { 2063 return this.getSuperFrontEndParameter().getTargetDependencies(); 2064 } 2065 2066 /** 2067 * Get the template parameter for this model element having the parameterName 2068 * @see ModelElementFacade#getTemplateParameter(String parameterName) 2069 */ 2070 public Object getTemplateParameter(String parameterName) 2071 { 2072 return this.getSuperFrontEndParameter().getTemplateParameter(parameterName); 2073 } 2074 2075 /** 2076 * Get the template parameters for this model element 2077 * @see ModelElementFacade#getTemplateParameters() 2078 */ 2079 public Collection<TemplateParameterFacade> getTemplateParameters() 2080 { 2081 return this.getSuperFrontEndParameter().getTemplateParameters(); 2082 } 2083 2084 /** 2085 * The visibility (i.e. public, private, protected or package) of the model element, will 2086 * attempt a lookup for these values in the language mappings (if any). 2087 * @see ModelElementFacade#getVisibility() 2088 */ 2089 public String getVisibility() 2090 { 2091 return this.getSuperFrontEndParameter().getVisibility(); 2092 } 2093 2094 /** 2095 * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance 2096 * is taken into account when searching for the stereotype), false otherwise. 2097 * @see ModelElementFacade#hasExactStereotype(String stereotypeName) 2098 */ 2099 public boolean hasExactStereotype(String stereotypeName) 2100 { 2101 return this.getSuperFrontEndParameter().hasExactStereotype(stereotypeName); 2102 } 2103 2104 /** 2105 * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma, 2106 * pipe, semicolon, or << >> 2107 * @see ModelElementFacade#hasKeyword(String keywordName) 2108 */ 2109 public boolean hasKeyword(String keywordName) 2110 { 2111 return this.getSuperFrontEndParameter().hasKeyword(keywordName); 2112 } 2113 2114 /** 2115 * Returns true if the model element has the specified stereotype. If the stereotype itself 2116 * does not match, then a search will be made up the stereotype inheritance hierarchy, and if 2117 * one of the stereotype's ancestors has a matching name this method will return true, false 2118 * otherwise. 2119 * For example, if we have a certain stereotype called <<exception>> and a model element has a 2120 * stereotype called <<applicationException>> which extends <<exception>>, when calling this 2121 * method with 'stereotypeName' defined as 'exception' the method would return true since 2122 * <<applicationException>> inherits from <<exception>>. If you want to check if the model 2123 * element has the exact stereotype, then use the method 'hasExactStereotype' instead. 2124 * @see ModelElementFacade#hasStereotype(String stereotypeName) 2125 */ 2126 public boolean hasStereotype(String stereotypeName) 2127 { 2128 return this.getSuperFrontEndParameter().hasStereotype(stereotypeName); 2129 } 2130 2131 /** 2132 * True if there are target dependencies from this element that are instances of BindingFacade. 2133 * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies. 2134 * @see ModelElementFacade#isBindingDependenciesPresent() 2135 */ 2136 public boolean isBindingDependenciesPresent() 2137 { 2138 return this.getSuperFrontEndParameter().isBindingDependenciesPresent(); 2139 } 2140 2141 /** 2142 * Indicates if any constraints are present on this model element. 2143 * @see ModelElementFacade#isConstraintsPresent() 2144 */ 2145 public boolean isConstraintsPresent() 2146 { 2147 return this.getSuperFrontEndParameter().isConstraintsPresent(); 2148 } 2149 2150 /** 2151 * Indicates if any documentation is present on this model element. 2152 * @see ModelElementFacade#isDocumentationPresent() 2153 */ 2154 public boolean isDocumentationPresent() 2155 { 2156 return this.getSuperFrontEndParameter().isDocumentationPresent(); 2157 } 2158 2159 /** 2160 * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript. 2161 * @see ModelElementFacade#isReservedWord() 2162 */ 2163 public boolean isReservedWord() 2164 { 2165 return this.getSuperFrontEndParameter().isReservedWord(); 2166 } 2167 2168 /** 2169 * True is there are template parameters on this model element. For UML2, applies to Class, 2170 * Operation, Property, and Parameter. 2171 * @see ModelElementFacade#isTemplateParametersPresent() 2172 */ 2173 public boolean isTemplateParametersPresent() 2174 { 2175 return this.getSuperFrontEndParameter().isTemplateParametersPresent(); 2176 } 2177 2178 /** 2179 * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++, 2180 * JavaScript. Contains no spaces, special characters etc. Constraint always applied on 2181 * Enumerations and Interfaces, optionally applies on other model elements. 2182 * @see ModelElementFacade#isValidIdentifierName() 2183 */ 2184 public boolean isValidIdentifierName() 2185 { 2186 return this.getSuperFrontEndParameter().isValidIdentifierName(); 2187 } 2188 2189 /** 2190 * Searches for the constraint with the specified 'name' on this model element, and if found 2191 * translates it using the specified 'translation' from a translation library discovered by the 2192 * framework. 2193 * @see ModelElementFacade#translateConstraint(String name, String translation) 2194 */ 2195 public String translateConstraint(String name, String translation) 2196 { 2197 return this.getSuperFrontEndParameter().translateConstraint(name, translation); 2198 } 2199 2200 /** 2201 * Translates all constraints belonging to this model element with the given 'translation'. 2202 * @see ModelElementFacade#translateConstraints(String translation) 2203 */ 2204 public String[] translateConstraints(String translation) 2205 { 2206 return this.getSuperFrontEndParameter().translateConstraints(translation); 2207 } 2208 2209 /** 2210 * Translates the constraints of the specified 'kind' belonging to this model element. 2211 * @see ModelElementFacade#translateConstraints(String kind, String translation) 2212 */ 2213 public String[] translateConstraints(String kind, String translation) 2214 { 2215 return this.getSuperFrontEndParameter().translateConstraints(kind, translation); 2216 } 2217 2218 /** 2219 * TODO: Model Documentation for org.andromda.metafacades.uml.ParameterFacade.defaultValue 2220 * @see org.andromda.metafacades.uml.ParameterFacade#getDefaultValue() 2221 */ 2222 public String getDefaultValue() 2223 { 2224 return this.getSuperFrontEndParameter().getDefaultValue(); 2225 } 2226 2227 /** 2228 * UML2: A representation of the literals of the enumeration 'Parameter Effect Kind': CREATE, 2229 * READ, UPDATE, DELETE. The datatype ParameterEffectKind is an enumeration that indicates the 2230 * effect of a behavior on values passed in or out of its parameters. 2231 * @see org.andromda.metafacades.uml.ParameterFacade#getEffect() 2232 */ 2233 public String getEffect() 2234 { 2235 return this.getSuperFrontEndParameter().getEffect(); 2236 } 2237 2238 /** 2239 * If this parameter is located on an event, this will represent that event. 2240 * @see org.andromda.metafacades.uml.ParameterFacade#getEvent() 2241 */ 2242 public EventFacade getEvent() 2243 { 2244 return this.getSuperFrontEndParameter().getEvent(); 2245 } 2246 2247 /** 2248 * The name to use for accessors getting this parameter from a bean. 2249 * @see org.andromda.metafacades.uml.ParameterFacade#getGetterName() 2250 */ 2251 public String getGetterName() 2252 { 2253 return this.getSuperFrontEndParameter().getGetterName(); 2254 } 2255 2256 /** 2257 * Fully Qualified TypeName, determined in part by multiplicity (for UML2). For UML14, same as 2258 * getterName. 2259 * @see org.andromda.metafacades.uml.ParameterFacade#getGetterSetterTypeName() 2260 */ 2261 public String getGetterSetterTypeName() 2262 { 2263 return this.getSuperFrontEndParameter().getGetterSetterTypeName(); 2264 } 2265 2266 /** 2267 * Fully Qualified implementation class of TypeName, determined in part by multiplicity (for 2268 * UML2). If upper multiplicity =1, same as getterSetterTypeName. 2269 * @see org.andromda.metafacades.uml.ParameterFacade#getGetterSetterTypeNameImpl() 2270 */ 2271 public String getGetterSetterTypeNameImpl() 2272 { 2273 return this.getSuperFrontEndParameter().getGetterSetterTypeNameImpl(); 2274 } 2275 2276 /** 2277 * the lower value for the multiplicity 2278 * -only applicable for UML2 2279 * @see org.andromda.metafacades.uml.ParameterFacade#getLower() 2280 */ 2281 public int getLower() 2282 { 2283 return this.getSuperFrontEndParameter().getLower(); 2284 } 2285 2286 /** 2287 * If this parameter is located on an operation, this will represent that operation. 2288 * @see org.andromda.metafacades.uml.ParameterFacade#getOperation() 2289 */ 2290 public OperationFacade getOperation() 2291 { 2292 return this.getSuperFrontEndParameter().getOperation(); 2293 } 2294 2295 /** 2296 * The name to use for accessors getting this parameter in a bean. 2297 * @see org.andromda.metafacades.uml.ParameterFacade#getSetterName() 2298 */ 2299 public String getSetterName() 2300 { 2301 return this.getSuperFrontEndParameter().getSetterName(); 2302 } 2303 2304 /** 2305 * A Classifier is a classification of instances - it describes a set of instances that have 2306 * features 2307 * in common. Can specify a generalization hierarchy by referencing its general classifiers. It 2308 * may be 2309 * a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a 2310 * generalization hierarchy by referencing its general classifiers. Has the capability to own 2311 * collaboration uses. These collaboration uses link a collaboration with the classifier to give 2312 * a 2313 * description of the workings of the classifier. Classifier is defined to be a kind of 2314 * templateable 2315 * element so that a classifier can be parameterized. It is also defined to be a kind of 2316 * parameterable 2317 * element so that a classifier can be a formal template parameter. 2318 * @see org.andromda.metafacades.uml.ParameterFacade#getType() 2319 */ 2320 public ClassifierFacade getType() 2321 { 2322 return this.getSuperFrontEndParameter().getType(); 2323 } 2324 2325 /** 2326 * the upper value of the multiplicity (will be -1 for *) 2327 * -only applicable for UML2 2328 * @see org.andromda.metafacades.uml.ParameterFacade#getUpper() 2329 */ 2330 public int getUpper() 2331 { 2332 return this.getSuperFrontEndParameter().getUpper(); 2333 } 2334 2335 /** 2336 * Indicates if the default value is present. 2337 * @see org.andromda.metafacades.uml.ParameterFacade#isDefaultValuePresent() 2338 */ 2339 public boolean isDefaultValuePresent() 2340 { 2341 return this.getSuperFrontEndParameter().isDefaultValuePresent(); 2342 } 2343 2344 /** 2345 * UML2: Returns the value of the 'Is Exception' attribute. The default value is "false". Tells 2346 * whether an output parameter may emit a value to the exclusion of the other outputs. 2347 * @see org.andromda.metafacades.uml.ParameterFacade#isException() 2348 */ 2349 public boolean isException() 2350 { 2351 return this.getSuperFrontEndParameter().isException(); 2352 } 2353 2354 /** 2355 * True if this parameter is an 'in' parameter. 2356 * @see org.andromda.metafacades.uml.ParameterFacade#isInParameter() 2357 */ 2358 public boolean isInParameter() 2359 { 2360 return this.getSuperFrontEndParameter().isInParameter(); 2361 } 2362 2363 /** 2364 * True if this parameter is an inout parameter. 2365 * @see org.andromda.metafacades.uml.ParameterFacade#isInoutParameter() 2366 */ 2367 public boolean isInoutParameter() 2368 { 2369 return this.getSuperFrontEndParameter().isInoutParameter(); 2370 } 2371 2372 /** 2373 * If upper>1 or upper==unlimited. Only applies to UML2. For UML14, always false. 2374 * @see org.andromda.metafacades.uml.ParameterFacade#isMany() 2375 */ 2376 public boolean isMany() 2377 { 2378 return this.getSuperFrontEndParameter().isMany(); 2379 } 2380 2381 /** 2382 * UML2 Only: Is parameter ordered within the Collection type. Ordered+Unique determines the 2383 * implementation Collection Type. For UML14, always false. 2384 * @see org.andromda.metafacades.uml.ParameterFacade#isOrdered() 2385 */ 2386 public boolean isOrdered() 2387 { 2388 return this.getSuperFrontEndParameter().isOrdered(); 2389 } 2390 2391 /** 2392 * True if this parameter is an 'out' parameter. 2393 * @see org.andromda.metafacades.uml.ParameterFacade#isOutParameter() 2394 */ 2395 public boolean isOutParameter() 2396 { 2397 return this.getSuperFrontEndParameter().isOutParameter(); 2398 } 2399 2400 /** 2401 * True if this parameter is readable, aka an in-parameter, or this feature is unspecified. 2402 * @see org.andromda.metafacades.uml.ParameterFacade#isReadable() 2403 */ 2404 public boolean isReadable() 2405 { 2406 return this.getSuperFrontEndParameter().isReadable(); 2407 } 2408 2409 /** 2410 * Whether or not this parameter is considered required (i.e must a non-empty value). 2411 * @see org.andromda.metafacades.uml.ParameterFacade#isRequired() 2412 */ 2413 public boolean isRequired() 2414 { 2415 return this.getSuperFrontEndParameter().isRequired(); 2416 } 2417 2418 /** 2419 * Whether or not this parameter represents a return parameter. 2420 * @see org.andromda.metafacades.uml.ParameterFacade#isReturn() 2421 */ 2422 public boolean isReturn() 2423 { 2424 return this.getSuperFrontEndParameter().isReturn(); 2425 } 2426 2427 /** 2428 * If Parameter type isMany (UML2), is the parameter unique within the Collection. Unique+Sorted 2429 * determines pareter implementation type. For UML14, always false. 2430 * @see org.andromda.metafacades.uml.ParameterFacade#isUnique() 2431 */ 2432 public boolean isUnique() 2433 { 2434 return this.getSuperFrontEndParameter().isUnique(); 2435 } 2436 2437 /** 2438 * True if this parameter is writable, aka an out-parameter, or this feature is unspecified. 2439 * @see org.andromda.metafacades.uml.ParameterFacade#isWritable() 2440 */ 2441 public boolean isWritable() 2442 { 2443 return this.getSuperFrontEndParameter().isWritable(); 2444 } 2445 2446 /** 2447 * @see org.andromda.core.metafacade.MetafacadeBase#initialize() 2448 */ 2449 @Override 2450 public void initialize() 2451 { 2452 this.getSuperFrontEndParameter().initialize(); 2453 } 2454 2455 /** 2456 * @return Object getSuperFrontEndParameter().getValidationOwner() 2457 * @see org.andromda.core.metafacade.MetafacadeBase#getValidationOwner() 2458 */ 2459 @Override 2460 public Object getValidationOwner() 2461 { 2462 Object owner = this.getSuperFrontEndParameter().getValidationOwner(); 2463 return owner; 2464 } 2465 2466 /** 2467 * @return String getSuperFrontEndParameter().getValidationName() 2468 * @see org.andromda.core.metafacade.MetafacadeBase#getValidationName() 2469 */ 2470 @Override 2471 public String getValidationName() 2472 { 2473 String name = this.getSuperFrontEndParameter().getValidationName(); 2474 return name; 2475 } 2476 2477 /** 2478 * @param validationMessages Collection<ModelValidationMessage> 2479 * @see org.andromda.core.metafacade.MetafacadeBase#validateInvariants(Collection validationMessages) 2480 */ 2481 @Override 2482 public void validateInvariants(Collection<ModelValidationMessage> validationMessages) 2483 { 2484 this.getSuperFrontEndParameter().validateInvariants(validationMessages); 2485 } 2486 2487 /** 2488 * The property that stores the name of the metafacade. 2489 */ 2490 private static final String NAME_PROPERTY = "name"; 2491 private static final String FQNAME_PROPERTY = "fullyQualifiedName"; 2492 2493 /** 2494 * @see Object#toString() 2495 */ 2496 @Override 2497 public String toString() 2498 { 2499 final StringBuilder toString = new StringBuilder(this.getClass().getName()); 2500 toString.append("["); 2501 try 2502 { 2503 toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY)); 2504 } 2505 catch (final Throwable tryAgain) 2506 { 2507 try 2508 { 2509 toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY)); 2510 } 2511 catch (final Throwable ignore) 2512 { 2513 // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property 2514 } 2515 } 2516 toString.append("]"); 2517 return toString.toString(); 2518 } 2519}