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