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 org.andromda.core.common.Introspector; 009import org.andromda.core.metafacade.MetafacadeBase; 010import org.andromda.core.metafacade.MetafacadeFactory; 011import org.andromda.core.metafacade.ModelValidationMessage; 012import org.andromda.metafacades.uml.ClassifierFacade; 013import org.andromda.metafacades.uml.ConstraintFacade; 014import org.andromda.metafacades.uml.DependencyFacade; 015import org.andromda.metafacades.uml.EnumerationFacade; 016import org.andromda.metafacades.uml.ManageableEntityAttribute; 017import org.andromda.metafacades.uml.ModelElementFacade; 018import org.andromda.metafacades.uml.ModelFacade; 019import org.andromda.metafacades.uml.PackageFacade; 020import org.andromda.metafacades.uml.ParameterFacade; 021import org.andromda.metafacades.uml.StateMachineFacade; 022import org.andromda.metafacades.uml.StereotypeFacade; 023import org.andromda.metafacades.uml.TaggedValueFacade; 024import org.andromda.metafacades.uml.TemplateParameterFacade; 025import org.andromda.metafacades.uml.TypeMappings; 026 027/** 028 * TODO: Model Documentation for 029 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute 030 * MetafacadeLogic for JSFManageableEntityAttribute 031 * 032 * @see JSFManageableEntityAttribute 033 */ 034public abstract class JSFManageableEntityAttributeLogic 035 extends MetafacadeBase 036 implements JSFManageableEntityAttribute 037{ 038 /** 039 * The underlying UML object 040 * @see Object 041 */ 042 protected Object metaObject; 043 044 /** Create Metafacade implementation instance using the MetafacadeFactory from the context 045 * @param metaObjectIn 046 * @param context 047 */ 048 protected JSFManageableEntityAttributeLogic(Object metaObjectIn, String context) 049 { 050 super(metaObjectIn, getContext(context)); 051 this.superManageableEntityAttribute = 052 (ManageableEntityAttribute) 053 MetafacadeFactory.getInstance().createFacadeImpl( 054 "org.andromda.metafacades.uml.ManageableEntityAttribute", 055 metaObjectIn, 056 getContext(context)); 057 this.metaObject = metaObjectIn; 058 } 059 060 /** 061 * Gets the context for this metafacade logic instance. 062 * @param context String. Set to JSFManageableEntityAttribute if null 063 * @return context String 064 */ 065 private static String getContext(String context) 066 { 067 if (context == null) 068 { 069 context = "org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute"; 070 } 071 return context; 072 } 073 074 private ManageableEntityAttribute superManageableEntityAttribute; 075 private boolean superManageableEntityAttributeInitialized = false; 076 077 /** 078 * Gets the ManageableEntityAttribute parent instance. 079 * @return this.superManageableEntityAttribute ManageableEntityAttribute 080 */ 081 private ManageableEntityAttribute getSuperManageableEntityAttribute() 082 { 083 if (!this.superManageableEntityAttributeInitialized) 084 { 085 ((MetafacadeBase)this.superManageableEntityAttribute).setMetafacadeContext(this.getMetafacadeContext()); 086 this.superManageableEntityAttributeInitialized = true; 087 } 088 return this.superManageableEntityAttribute; 089 } 090 091 /** Reset context only for non-root metafacades 092 * @param context 093 * @see org.andromda.core.metafacade.MetafacadeBase#resetMetafacadeContext(String context) 094 */ 095 @Override 096 public void resetMetafacadeContext(String context) 097 { 098 if (!this.contextRoot) // reset context only for non-root metafacades 099 { 100 context = getContext(context); // to have same value as in original constructor call 101 setMetafacadeContext (context); 102 if (this.superManageableEntityAttributeInitialized) 103 { 104 ((MetafacadeBase)this.superManageableEntityAttribute).resetMetafacadeContext(context); 105 } 106 } 107 } 108 109 /** 110 * @return boolean true always 111 * @see JSFManageableEntityAttribute 112 */ 113 public boolean isJSFManageableEntityAttributeMetaType() 114 { 115 return true; 116 } 117 118 // --------------- attributes --------------------- 119 120 /** 121 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getMessageKey() 122 * @return String 123 */ 124 protected abstract String handleGetMessageKey(); 125 126 private String __messageKey1a; 127 private boolean __messageKey1aSet = false; 128 129 /** 130 * TODO: Model Documentation for 131 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.messageKey 132 * @return (String)handleGetMessageKey() 133 */ 134 public final String getMessageKey() 135 { 136 String messageKey1a = this.__messageKey1a; 137 if (!this.__messageKey1aSet) 138 { 139 // messageKey has no pre constraints 140 messageKey1a = handleGetMessageKey(); 141 // messageKey has no post constraints 142 this.__messageKey1a = messageKey1a; 143 if (isMetafacadePropertyCachingEnabled()) 144 { 145 this.__messageKey1aSet = true; 146 } 147 } 148 return messageKey1a; 149 } 150 151 /** 152 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getMessageValue() 153 * @return String 154 */ 155 protected abstract String handleGetMessageValue(); 156 157 private String __messageValue2a; 158 private boolean __messageValue2aSet = false; 159 160 /** 161 * TODO: Model Documentation for 162 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.messageValue 163 * @return (String)handleGetMessageValue() 164 */ 165 public final String getMessageValue() 166 { 167 String messageValue2a = this.__messageValue2a; 168 if (!this.__messageValue2aSet) 169 { 170 // messageValue has no pre constraints 171 messageValue2a = handleGetMessageValue(); 172 // messageValue has no post constraints 173 this.__messageValue2a = messageValue2a; 174 if (isMetafacadePropertyCachingEnabled()) 175 { 176 this.__messageValue2aSet = true; 177 } 178 } 179 return messageValue2a; 180 } 181 182 /** 183 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getDateFormat() 184 * @return String 185 */ 186 protected abstract String handleGetDateFormat(); 187 188 private String __dateFormat3a; 189 private boolean __dateFormat3aSet = false; 190 191 /** 192 * The String format to use when referring to this date, only makes sense when the type is a 193 * date type. 194 * @return (String)handleGetDateFormat() 195 */ 196 public final String getDateFormat() 197 { 198 String dateFormat3a = this.__dateFormat3a; 199 if (!this.__dateFormat3aSet) 200 { 201 // dateFormat has no pre constraints 202 dateFormat3a = handleGetDateFormat(); 203 // dateFormat has no post constraints 204 this.__dateFormat3a = dateFormat3a; 205 if (isMetafacadePropertyCachingEnabled()) 206 { 207 this.__dateFormat3aSet = true; 208 } 209 } 210 return dateFormat3a; 211 } 212 213 /** 214 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isNeedsFileUpload() 215 * @return boolean 216 */ 217 protected abstract boolean handleIsNeedsFileUpload(); 218 219 private boolean __needsFileUpload4a; 220 private boolean __needsFileUpload4aSet = false; 221 222 /** 223 * True if this attribute is of a type that cannot easily be represented as a textual string and 224 * would be an ideal candidate for HTTP's support for file-upload. 225 * @return (boolean)handleIsNeedsFileUpload() 226 */ 227 public final boolean isNeedsFileUpload() 228 { 229 boolean needsFileUpload4a = this.__needsFileUpload4a; 230 if (!this.__needsFileUpload4aSet) 231 { 232 // needsFileUpload has no pre constraints 233 needsFileUpload4a = handleIsNeedsFileUpload(); 234 // needsFileUpload has no post constraints 235 this.__needsFileUpload4a = needsFileUpload4a; 236 if (isMetafacadePropertyCachingEnabled()) 237 { 238 this.__needsFileUpload4aSet = true; 239 } 240 } 241 return needsFileUpload4a; 242 } 243 244 /** 245 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isHidden() 246 * @return boolean 247 */ 248 protected abstract boolean handleIsHidden(); 249 250 private boolean __hidden5a; 251 private boolean __hidden5aSet = false; 252 253 /** 254 * Whether or not this attribute should be hidden from the view 255 * @return (boolean)handleIsHidden() 256 */ 257 public final boolean isHidden() 258 { 259 boolean hidden5a = this.__hidden5a; 260 if (!this.__hidden5aSet) 261 { 262 // hidden has no pre constraints 263 hidden5a = handleIsHidden(); 264 // hidden has no post constraints 265 this.__hidden5a = hidden5a; 266 if (isMetafacadePropertyCachingEnabled()) 267 { 268 this.__hidden5aSet = true; 269 } 270 } 271 return hidden5a; 272 } 273 274 /** 275 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getWidgetType() 276 * @return String 277 */ 278 protected abstract String handleGetWidgetType(); 279 280 private String __widgetType6a; 281 private boolean __widgetType6aSet = false; 282 283 /** 284 * The widget to use when rendering this attribute 285 * @return (String)handleGetWidgetType() 286 */ 287 public final String getWidgetType() 288 { 289 String widgetType6a = this.__widgetType6a; 290 if (!this.__widgetType6aSet) 291 { 292 // widgetType has no pre constraints 293 widgetType6a = handleGetWidgetType(); 294 // widgetType has no post constraints 295 this.__widgetType6a = widgetType6a; 296 if (isMetafacadePropertyCachingEnabled()) 297 { 298 this.__widgetType6aSet = true; 299 } 300 } 301 return widgetType6a; 302 } 303 304 /** 305 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isStrictDateFormat() 306 * @return boolean 307 */ 308 protected abstract boolean handleIsStrictDateFormat(); 309 310 private boolean __strictDateFormat7a; 311 private boolean __strictDateFormat7aSet = false; 312 313 /** 314 * True if this field is a date type and the date format is not be interpreted strictly. 315 * @return (boolean)handleIsStrictDateFormat() 316 */ 317 public final boolean isStrictDateFormat() 318 { 319 boolean strictDateFormat7a = this.__strictDateFormat7a; 320 if (!this.__strictDateFormat7aSet) 321 { 322 // strictDateFormat has no pre constraints 323 strictDateFormat7a = handleIsStrictDateFormat(); 324 // strictDateFormat has no post constraints 325 this.__strictDateFormat7a = strictDateFormat7a; 326 if (isMetafacadePropertyCachingEnabled()) 327 { 328 this.__strictDateFormat7aSet = true; 329 } 330 } 331 return strictDateFormat7a; 332 } 333 334 /** 335 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getOnlineHelpKey() 336 * @return String 337 */ 338 protected abstract String handleGetOnlineHelpKey(); 339 340 private String __onlineHelpKey8a; 341 private boolean __onlineHelpKey8aSet = false; 342 343 /** 344 * The key to lookup the online help documentation. This documentation is gathered from the 345 * documentation entered by the user, as well as analyzing the model. 346 * @return (String)handleGetOnlineHelpKey() 347 */ 348 public final String getOnlineHelpKey() 349 { 350 String onlineHelpKey8a = this.__onlineHelpKey8a; 351 if (!this.__onlineHelpKey8aSet) 352 { 353 // onlineHelpKey has no pre constraints 354 onlineHelpKey8a = handleGetOnlineHelpKey(); 355 // onlineHelpKey has no post constraints 356 this.__onlineHelpKey8a = onlineHelpKey8a; 357 if (isMetafacadePropertyCachingEnabled()) 358 { 359 this.__onlineHelpKey8aSet = true; 360 } 361 } 362 return onlineHelpKey8a; 363 } 364 365 /** 366 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getOnlineHelpValue() 367 * @return String 368 */ 369 protected abstract String handleGetOnlineHelpValue(); 370 371 private String __onlineHelpValue9a; 372 private boolean __onlineHelpValue9aSet = false; 373 374 /** 375 * The online help documentation. This documentation is gathered from the documentation entered 376 * by the user, as well as analyzing the model. The format is HTML without any style. 377 * @return (String)handleGetOnlineHelpValue() 378 */ 379 public final String getOnlineHelpValue() 380 { 381 String onlineHelpValue9a = this.__onlineHelpValue9a; 382 if (!this.__onlineHelpValue9aSet) 383 { 384 // onlineHelpValue has no pre constraints 385 onlineHelpValue9a = handleGetOnlineHelpValue(); 386 // onlineHelpValue has no post constraints 387 this.__onlineHelpValue9a = onlineHelpValue9a; 388 if (isMetafacadePropertyCachingEnabled()) 389 { 390 this.__onlineHelpValue9aSet = true; 391 } 392 } 393 return onlineHelpValue9a; 394 } 395 396 /** 397 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getFormat() 398 * @return String 399 */ 400 protected abstract String handleGetFormat(); 401 402 private String __format10a; 403 private boolean __format10aSet = false; 404 405 /** 406 * TODO: Model Documentation for 407 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.format 408 * @return (String)handleGetFormat() 409 */ 410 public final String getFormat() 411 { 412 String format10a = this.__format10a; 413 if (!this.__format10aSet) 414 { 415 // format has no pre constraints 416 format10a = handleGetFormat(); 417 // format has no post constraints 418 this.__format10a = format10a; 419 if (isMetafacadePropertyCachingEnabled()) 420 { 421 this.__format10aSet = true; 422 } 423 } 424 return format10a; 425 } 426 427 /** 428 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getDefaultDateFormat() 429 * @return String 430 */ 431 protected abstract String handleGetDefaultDateFormat(); 432 433 private String __defaultDateFormat11a; 434 private boolean __defaultDateFormat11aSet = false; 435 436 /** 437 * TODO: Model Documentation for 438 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.defaultDateFormat 439 * @return (String)handleGetDefaultDateFormat() 440 */ 441 public final String getDefaultDateFormat() 442 { 443 String defaultDateFormat11a = this.__defaultDateFormat11a; 444 if (!this.__defaultDateFormat11aSet) 445 { 446 // defaultDateFormat has no pre constraints 447 defaultDateFormat11a = handleGetDefaultDateFormat(); 448 // defaultDateFormat has no post constraints 449 this.__defaultDateFormat11a = defaultDateFormat11a; 450 if (isMetafacadePropertyCachingEnabled()) 451 { 452 this.__defaultDateFormat11aSet = true; 453 } 454 } 455 return defaultDateFormat11a; 456 } 457 458 /** 459 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getDefaultTimeFormat() 460 * @return String 461 */ 462 protected abstract String handleGetDefaultTimeFormat(); 463 464 private String __defaultTimeFormat12a; 465 private boolean __defaultTimeFormat12aSet = false; 466 467 /** 468 * TODO: Model Documentation for 469 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.defaultTimeFormat 470 * @return (String)handleGetDefaultTimeFormat() 471 */ 472 public final String getDefaultTimeFormat() 473 { 474 String defaultTimeFormat12a = this.__defaultTimeFormat12a; 475 if (!this.__defaultTimeFormat12aSet) 476 { 477 // defaultTimeFormat has no pre constraints 478 defaultTimeFormat12a = handleGetDefaultTimeFormat(); 479 // defaultTimeFormat has no post constraints 480 this.__defaultTimeFormat12a = defaultTimeFormat12a; 481 if (isMetafacadePropertyCachingEnabled()) 482 { 483 this.__defaultTimeFormat12aSet = true; 484 } 485 } 486 return defaultTimeFormat12a; 487 } 488 489 /** 490 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getDateFormatter() 491 * @return String 492 */ 493 protected abstract String handleGetDateFormatter(); 494 495 private String __dateFormatter13a; 496 private boolean __dateFormatter13aSet = false; 497 498 /** 499 * TODO: Model Documentation for 500 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.dateFormatter 501 * @return (String)handleGetDateFormatter() 502 */ 503 public final String getDateFormatter() 504 { 505 String dateFormatter13a = this.__dateFormatter13a; 506 if (!this.__dateFormatter13aSet) 507 { 508 // dateFormatter has no pre constraints 509 dateFormatter13a = handleGetDateFormatter(); 510 // dateFormatter has no post constraints 511 this.__dateFormatter13a = dateFormatter13a; 512 if (isMetafacadePropertyCachingEnabled()) 513 { 514 this.__dateFormatter13aSet = true; 515 } 516 } 517 return dateFormatter13a; 518 } 519 520 /** 521 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getTimeFormatter() 522 * @return String 523 */ 524 protected abstract String handleGetTimeFormatter(); 525 526 private String __timeFormatter14a; 527 private boolean __timeFormatter14aSet = false; 528 529 /** 530 * TODO: Model Documentation for 531 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.timeFormatter 532 * @return (String)handleGetTimeFormatter() 533 */ 534 public final String getTimeFormatter() 535 { 536 String timeFormatter14a = this.__timeFormatter14a; 537 if (!this.__timeFormatter14aSet) 538 { 539 // timeFormatter has no pre constraints 540 timeFormatter14a = handleGetTimeFormatter(); 541 // timeFormatter has no post constraints 542 this.__timeFormatter14a = timeFormatter14a; 543 if (isMetafacadePropertyCachingEnabled()) 544 { 545 this.__timeFormatter14aSet = true; 546 } 547 } 548 return timeFormatter14a; 549 } 550 551 /** 552 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getBackingListName() 553 * @return String 554 */ 555 protected abstract String handleGetBackingListName(); 556 557 private String __backingListName15a; 558 private boolean __backingListName15aSet = false; 559 560 /** 561 * TODO: Model Documentation for 562 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.backingListName 563 * @return (String)handleGetBackingListName() 564 */ 565 public final String getBackingListName() 566 { 567 String backingListName15a = this.__backingListName15a; 568 if (!this.__backingListName15aSet) 569 { 570 // backingListName has no pre constraints 571 backingListName15a = handleGetBackingListName(); 572 // backingListName has no post constraints 573 this.__backingListName15a = backingListName15a; 574 if (isMetafacadePropertyCachingEnabled()) 575 { 576 this.__backingListName15aSet = true; 577 } 578 } 579 return backingListName15a; 580 } 581 582 /** 583 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getValueListName() 584 * @return String 585 */ 586 protected abstract String handleGetValueListName(); 587 588 private String __valueListName16a; 589 private boolean __valueListName16aSet = false; 590 591 /** 592 * TODO: Model Documentation for 593 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.valueListName 594 * @return (String)handleGetValueListName() 595 */ 596 public final String getValueListName() 597 { 598 String valueListName16a = this.__valueListName16a; 599 if (!this.__valueListName16aSet) 600 { 601 // valueListName has no pre constraints 602 valueListName16a = handleGetValueListName(); 603 // valueListName has no post constraints 604 this.__valueListName16a = valueListName16a; 605 if (isMetafacadePropertyCachingEnabled()) 606 { 607 this.__valueListName16aSet = true; 608 } 609 } 610 return valueListName16a; 611 } 612 613 /** 614 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getLabelListName() 615 * @return String 616 */ 617 protected abstract String handleGetLabelListName(); 618 619 private String __labelListName17a; 620 private boolean __labelListName17aSet = false; 621 622 /** 623 * TODO: Model Documentation for 624 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.labelListName 625 * @return (String)handleGetLabelListName() 626 */ 627 public final String getLabelListName() 628 { 629 String labelListName17a = this.__labelListName17a; 630 if (!this.__labelListName17aSet) 631 { 632 // labelListName has no pre constraints 633 labelListName17a = handleGetLabelListName(); 634 // labelListName has no post constraints 635 this.__labelListName17a = labelListName17a; 636 if (isMetafacadePropertyCachingEnabled()) 637 { 638 this.__labelListName17aSet = true; 639 } 640 } 641 return labelListName17a; 642 } 643 644 /** 645 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getValidatorTypes() 646 * @return Collection 647 */ 648 protected abstract Collection handleGetValidatorTypes(); 649 650 private Collection __validatorTypes18a; 651 private boolean __validatorTypes18aSet = false; 652 653 /** 654 * All validator types for this attribute. 655 * @return (Collection)handleGetValidatorTypes() 656 */ 657 public final Collection getValidatorTypes() 658 { 659 Collection validatorTypes18a = this.__validatorTypes18a; 660 if (!this.__validatorTypes18aSet) 661 { 662 // validatorTypes has no pre constraints 663 validatorTypes18a = handleGetValidatorTypes(); 664 // validatorTypes has no post constraints 665 this.__validatorTypes18a = validatorTypes18a; 666 if (isMetafacadePropertyCachingEnabled()) 667 { 668 this.__validatorTypes18aSet = true; 669 } 670 } 671 return validatorTypes18a; 672 } 673 674 /** 675 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isValidationRequired() 676 * @return boolean 677 */ 678 protected abstract boolean handleIsValidationRequired(); 679 680 private boolean __validationRequired19a; 681 private boolean __validationRequired19aSet = false; 682 683 /** 684 * Indicates whether or not this attribute requires some kind of validation (the collection of 685 * validator types is not empty). 686 * @return (boolean)handleIsValidationRequired() 687 */ 688 public final boolean isValidationRequired() 689 { 690 boolean validationRequired19a = this.__validationRequired19a; 691 if (!this.__validationRequired19aSet) 692 { 693 // validationRequired has no pre constraints 694 validationRequired19a = handleIsValidationRequired(); 695 // validationRequired has no post constraints 696 this.__validationRequired19a = validationRequired19a; 697 if (isMetafacadePropertyCachingEnabled()) 698 { 699 this.__validationRequired19aSet = true; 700 } 701 } 702 return validationRequired19a; 703 } 704 705 /** 706 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getValidWhen() 707 * @return String 708 */ 709 protected abstract String handleGetValidWhen(); 710 711 private String __validWhen20a; 712 private boolean __validWhen20aSet = false; 713 714 /** 715 * TODO: Model Documentation for 716 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.validWhen 717 * @return (String)handleGetValidWhen() 718 */ 719 public final String getValidWhen() 720 { 721 String validWhen20a = this.__validWhen20a; 722 if (!this.__validWhen20aSet) 723 { 724 // validWhen has no pre constraints 725 validWhen20a = handleGetValidWhen(); 726 // validWhen has no post constraints 727 this.__validWhen20a = validWhen20a; 728 if (isMetafacadePropertyCachingEnabled()) 729 { 730 this.__validWhen20aSet = true; 731 } 732 } 733 return validWhen20a; 734 } 735 736 /** 737 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isInputCheckbox() 738 * @return boolean 739 */ 740 protected abstract boolean handleIsInputCheckbox(); 741 742 private boolean __inputCheckbox21a; 743 private boolean __inputCheckbox21aSet = false; 744 745 /** 746 * TODO: Model Documentation for 747 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.inputCheckbox 748 * @return (boolean)handleIsInputCheckbox() 749 */ 750 public final boolean isInputCheckbox() 751 { 752 boolean inputCheckbox21a = this.__inputCheckbox21a; 753 if (!this.__inputCheckbox21aSet) 754 { 755 // inputCheckbox has no pre constraints 756 inputCheckbox21a = handleIsInputCheckbox(); 757 // inputCheckbox has no post constraints 758 this.__inputCheckbox21a = inputCheckbox21a; 759 if (isMetafacadePropertyCachingEnabled()) 760 { 761 this.__inputCheckbox21aSet = true; 762 } 763 } 764 return inputCheckbox21a; 765 } 766 767 /** 768 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isInputFile() 769 * @return boolean 770 */ 771 protected abstract boolean handleIsInputFile(); 772 773 private boolean __inputFile22a; 774 private boolean __inputFile22aSet = false; 775 776 /** 777 * TODO: Model Documentation for 778 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.inputFile 779 * @return (boolean)handleIsInputFile() 780 */ 781 public final boolean isInputFile() 782 { 783 boolean inputFile22a = this.__inputFile22a; 784 if (!this.__inputFile22aSet) 785 { 786 // inputFile has no pre constraints 787 inputFile22a = handleIsInputFile(); 788 // inputFile has no post constraints 789 this.__inputFile22a = inputFile22a; 790 if (isMetafacadePropertyCachingEnabled()) 791 { 792 this.__inputFile22aSet = true; 793 } 794 } 795 return inputFile22a; 796 } 797 798 /** 799 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isInputHidden() 800 * @return boolean 801 */ 802 protected abstract boolean handleIsInputHidden(); 803 804 private boolean __inputHidden23a; 805 private boolean __inputHidden23aSet = false; 806 807 /** 808 * TODO: Model Documentation for 809 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.inputHidden 810 * @return (boolean)handleIsInputHidden() 811 */ 812 public final boolean isInputHidden() 813 { 814 boolean inputHidden23a = this.__inputHidden23a; 815 if (!this.__inputHidden23aSet) 816 { 817 // inputHidden has no pre constraints 818 inputHidden23a = handleIsInputHidden(); 819 // inputHidden has no post constraints 820 this.__inputHidden23a = inputHidden23a; 821 if (isMetafacadePropertyCachingEnabled()) 822 { 823 this.__inputHidden23aSet = true; 824 } 825 } 826 return inputHidden23a; 827 } 828 829 /** 830 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isInputMultibox() 831 * @return boolean 832 */ 833 protected abstract boolean handleIsInputMultibox(); 834 835 private boolean __inputMultibox24a; 836 private boolean __inputMultibox24aSet = false; 837 838 /** 839 * TODO: Model Documentation for 840 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.inputMultibox 841 * @return (boolean)handleIsInputMultibox() 842 */ 843 public final boolean isInputMultibox() 844 { 845 boolean inputMultibox24a = this.__inputMultibox24a; 846 if (!this.__inputMultibox24aSet) 847 { 848 // inputMultibox has no pre constraints 849 inputMultibox24a = handleIsInputMultibox(); 850 // inputMultibox has no post constraints 851 this.__inputMultibox24a = inputMultibox24a; 852 if (isMetafacadePropertyCachingEnabled()) 853 { 854 this.__inputMultibox24aSet = true; 855 } 856 } 857 return inputMultibox24a; 858 } 859 860 /** 861 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isInputRadio() 862 * @return boolean 863 */ 864 protected abstract boolean handleIsInputRadio(); 865 866 private boolean __inputRadio25a; 867 private boolean __inputRadio25aSet = false; 868 869 /** 870 * TODO: Model Documentation for 871 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.inputRadio 872 * @return (boolean)handleIsInputRadio() 873 */ 874 public final boolean isInputRadio() 875 { 876 boolean inputRadio25a = this.__inputRadio25a; 877 if (!this.__inputRadio25aSet) 878 { 879 // inputRadio has no pre constraints 880 inputRadio25a = handleIsInputRadio(); 881 // inputRadio has no post constraints 882 this.__inputRadio25a = inputRadio25a; 883 if (isMetafacadePropertyCachingEnabled()) 884 { 885 this.__inputRadio25aSet = true; 886 } 887 } 888 return inputRadio25a; 889 } 890 891 /** 892 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isInputSecret() 893 * @return boolean 894 */ 895 protected abstract boolean handleIsInputSecret(); 896 897 private boolean __inputSecret26a; 898 private boolean __inputSecret26aSet = false; 899 900 /** 901 * TODO: Model Documentation for 902 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.inputSecret 903 * @return (boolean)handleIsInputSecret() 904 */ 905 public final boolean isInputSecret() 906 { 907 boolean inputSecret26a = this.__inputSecret26a; 908 if (!this.__inputSecret26aSet) 909 { 910 // inputSecret has no pre constraints 911 inputSecret26a = handleIsInputSecret(); 912 // inputSecret has no post constraints 913 this.__inputSecret26a = inputSecret26a; 914 if (isMetafacadePropertyCachingEnabled()) 915 { 916 this.__inputSecret26aSet = true; 917 } 918 } 919 return inputSecret26a; 920 } 921 922 /** 923 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isInputSelect() 924 * @return boolean 925 */ 926 protected abstract boolean handleIsInputSelect(); 927 928 private boolean __inputSelect27a; 929 private boolean __inputSelect27aSet = false; 930 931 /** 932 * TODO: Model Documentation for 933 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.inputSelect 934 * @return (boolean)handleIsInputSelect() 935 */ 936 public final boolean isInputSelect() 937 { 938 boolean inputSelect27a = this.__inputSelect27a; 939 if (!this.__inputSelect27aSet) 940 { 941 // inputSelect has no pre constraints 942 inputSelect27a = handleIsInputSelect(); 943 // inputSelect has no post constraints 944 this.__inputSelect27a = inputSelect27a; 945 if (isMetafacadePropertyCachingEnabled()) 946 { 947 this.__inputSelect27aSet = true; 948 } 949 } 950 return inputSelect27a; 951 } 952 953 /** 954 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isInputTable() 955 * @return boolean 956 */ 957 protected abstract boolean handleIsInputTable(); 958 959 private boolean __inputTable28a; 960 private boolean __inputTable28aSet = false; 961 962 /** 963 * TODO: Model Documentation for 964 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.inputTable 965 * @return (boolean)handleIsInputTable() 966 */ 967 public final boolean isInputTable() 968 { 969 boolean inputTable28a = this.__inputTable28a; 970 if (!this.__inputTable28aSet) 971 { 972 // inputTable has no pre constraints 973 inputTable28a = handleIsInputTable(); 974 // inputTable has no post constraints 975 this.__inputTable28a = inputTable28a; 976 if (isMetafacadePropertyCachingEnabled()) 977 { 978 this.__inputTable28aSet = true; 979 } 980 } 981 return inputTable28a; 982 } 983 984 /** 985 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getInputTableIdentifierColumns() 986 * @return String 987 */ 988 protected abstract String handleGetInputTableIdentifierColumns(); 989 990 private String __inputTableIdentifierColumns29a; 991 private boolean __inputTableIdentifierColumns29aSet = false; 992 993 /** 994 * TODO: Model Documentation for 995 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.inputTableIdentifierColumns 996 * @return (String)handleGetInputTableIdentifierColumns() 997 */ 998 public final String getInputTableIdentifierColumns() 999 { 1000 String inputTableIdentifierColumns29a = this.__inputTableIdentifierColumns29a; 1001 if (!this.__inputTableIdentifierColumns29aSet) 1002 { 1003 // inputTableIdentifierColumns has no pre constraints 1004 inputTableIdentifierColumns29a = handleGetInputTableIdentifierColumns(); 1005 // inputTableIdentifierColumns has no post constraints 1006 this.__inputTableIdentifierColumns29a = inputTableIdentifierColumns29a; 1007 if (isMetafacadePropertyCachingEnabled()) 1008 { 1009 this.__inputTableIdentifierColumns29aSet = true; 1010 } 1011 } 1012 return inputTableIdentifierColumns29a; 1013 } 1014 1015 /** 1016 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isInputText() 1017 * @return boolean 1018 */ 1019 protected abstract boolean handleIsInputText(); 1020 1021 private boolean __inputText30a; 1022 private boolean __inputText30aSet = false; 1023 1024 /** 1025 * TODO: Model Documentation for 1026 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.inputText 1027 * @return (boolean)handleIsInputText() 1028 */ 1029 public final boolean isInputText() 1030 { 1031 boolean inputText30a = this.__inputText30a; 1032 if (!this.__inputText30aSet) 1033 { 1034 // inputText has no pre constraints 1035 inputText30a = handleIsInputText(); 1036 // inputText has no post constraints 1037 this.__inputText30a = inputText30a; 1038 if (isMetafacadePropertyCachingEnabled()) 1039 { 1040 this.__inputText30aSet = true; 1041 } 1042 } 1043 return inputText30a; 1044 } 1045 1046 /** 1047 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isInputTextarea() 1048 * @return boolean 1049 */ 1050 protected abstract boolean handleIsInputTextarea(); 1051 1052 private boolean __inputTextarea31a; 1053 private boolean __inputTextarea31aSet = false; 1054 1055 /** 1056 * TODO: Model Documentation for 1057 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.inputTextarea 1058 * @return (boolean)handleIsInputTextarea() 1059 */ 1060 public final boolean isInputTextarea() 1061 { 1062 boolean inputTextarea31a = this.__inputTextarea31a; 1063 if (!this.__inputTextarea31aSet) 1064 { 1065 // inputTextarea has no pre constraints 1066 inputTextarea31a = handleIsInputTextarea(); 1067 // inputTextarea has no post constraints 1068 this.__inputTextarea31a = inputTextarea31a; 1069 if (isMetafacadePropertyCachingEnabled()) 1070 { 1071 this.__inputTextarea31aSet = true; 1072 } 1073 } 1074 return inputTextarea31a; 1075 } 1076 1077 /** 1078 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isInputTypePresent() 1079 * @return boolean 1080 */ 1081 protected abstract boolean handleIsInputTypePresent(); 1082 1083 private boolean __inputTypePresent32a; 1084 private boolean __inputTypePresent32aSet = false; 1085 1086 /** 1087 * TODO: Model Documentation for 1088 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.inputTypePresent 1089 * @return (boolean)handleIsInputTypePresent() 1090 */ 1091 public final boolean isInputTypePresent() 1092 { 1093 boolean inputTypePresent32a = this.__inputTypePresent32a; 1094 if (!this.__inputTypePresent32aSet) 1095 { 1096 // inputTypePresent has no pre constraints 1097 inputTypePresent32a = handleIsInputTypePresent(); 1098 // inputTypePresent has no post constraints 1099 this.__inputTypePresent32a = inputTypePresent32a; 1100 if (isMetafacadePropertyCachingEnabled()) 1101 { 1102 this.__inputTypePresent32aSet = true; 1103 } 1104 } 1105 return inputTypePresent32a; 1106 } 1107 1108 /** 1109 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getDummyValue() 1110 * @return String 1111 */ 1112 protected abstract String handleGetDummyValue(); 1113 1114 private String __dummyValue33a; 1115 private boolean __dummyValue33aSet = false; 1116 1117 /** 1118 * TODO: Model Documentation for 1119 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.dummyValue 1120 * @return (String)handleGetDummyValue() 1121 */ 1122 public final String getDummyValue() 1123 { 1124 String dummyValue33a = this.__dummyValue33a; 1125 if (!this.__dummyValue33aSet) 1126 { 1127 // dummyValue has no pre constraints 1128 dummyValue33a = handleGetDummyValue(); 1129 // dummyValue has no post constraints 1130 this.__dummyValue33a = dummyValue33a; 1131 if (isMetafacadePropertyCachingEnabled()) 1132 { 1133 this.__dummyValue33aSet = true; 1134 } 1135 } 1136 return dummyValue33a; 1137 } 1138 1139 /** 1140 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isEqualValidator() 1141 * @return boolean 1142 */ 1143 protected abstract boolean handleIsEqualValidator(); 1144 1145 private boolean __equalValidator34a; 1146 private boolean __equalValidator34aSet = false; 1147 1148 /** 1149 * TODO: Model Documentation for 1150 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.equalValidator 1151 * @return (boolean)handleIsEqualValidator() 1152 */ 1153 public final boolean isEqualValidator() 1154 { 1155 boolean equalValidator34a = this.__equalValidator34a; 1156 if (!this.__equalValidator34aSet) 1157 { 1158 // equalValidator has no pre constraints 1159 equalValidator34a = handleIsEqualValidator(); 1160 // equalValidator has no post constraints 1161 this.__equalValidator34a = equalValidator34a; 1162 if (isMetafacadePropertyCachingEnabled()) 1163 { 1164 this.__equalValidator34aSet = true; 1165 } 1166 } 1167 return equalValidator34a; 1168 } 1169 1170 /** 1171 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isPlaintext() 1172 * @return boolean 1173 */ 1174 protected abstract boolean handleIsPlaintext(); 1175 1176 private boolean __plaintext35a; 1177 private boolean __plaintext35aSet = false; 1178 1179 /** 1180 * TODO: Model Documentation for 1181 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.plaintext 1182 * @return (boolean)handleIsPlaintext() 1183 */ 1184 public final boolean isPlaintext() 1185 { 1186 boolean plaintext35a = this.__plaintext35a; 1187 if (!this.__plaintext35aSet) 1188 { 1189 // plaintext has no pre constraints 1190 plaintext35a = handleIsPlaintext(); 1191 // plaintext has no post constraints 1192 this.__plaintext35a = plaintext35a; 1193 if (isMetafacadePropertyCachingEnabled()) 1194 { 1195 this.__plaintext35aSet = true; 1196 } 1197 } 1198 return plaintext35a; 1199 } 1200 1201 /** 1202 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getValueListDummyValue() 1203 * @return String 1204 */ 1205 protected abstract String handleGetValueListDummyValue(); 1206 1207 private String __valueListDummyValue36a; 1208 private boolean __valueListDummyValue36aSet = false; 1209 1210 /** 1211 * TODO: Model Documentation for 1212 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.valueListDummyValue 1213 * @return (String)handleGetValueListDummyValue() 1214 */ 1215 public final String getValueListDummyValue() 1216 { 1217 String valueListDummyValue36a = this.__valueListDummyValue36a; 1218 if (!this.__valueListDummyValue36aSet) 1219 { 1220 // valueListDummyValue has no pre constraints 1221 valueListDummyValue36a = handleGetValueListDummyValue(); 1222 // valueListDummyValue has no post constraints 1223 this.__valueListDummyValue36a = valueListDummyValue36a; 1224 if (isMetafacadePropertyCachingEnabled()) 1225 { 1226 this.__valueListDummyValue36aSet = true; 1227 } 1228 } 1229 return valueListDummyValue36a; 1230 } 1231 1232 /** 1233 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getValidatorVars() 1234 * @return Collection 1235 */ 1236 protected abstract Collection handleGetValidatorVars(); 1237 1238 private Collection __validatorVars37a; 1239 private boolean __validatorVars37aSet = false; 1240 1241 /** 1242 * The validator variables. 1243 * @return (Collection)handleGetValidatorVars() 1244 */ 1245 public final Collection getValidatorVars() 1246 { 1247 Collection validatorVars37a = this.__validatorVars37a; 1248 if (!this.__validatorVars37aSet) 1249 { 1250 // validatorVars has no pre constraints 1251 validatorVars37a = handleGetValidatorVars(); 1252 // validatorVars has no post constraints 1253 this.__validatorVars37a = validatorVars37a; 1254 if (isMetafacadePropertyCachingEnabled()) 1255 { 1256 this.__validatorVars37aSet = true; 1257 } 1258 } 1259 return validatorVars37a; 1260 } 1261 1262 /** 1263 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#getMaxLength() 1264 * @return String 1265 */ 1266 protected abstract String handleGetMaxLength(); 1267 1268 private String __maxLength38a; 1269 private boolean __maxLength38aSet = false; 1270 1271 /** 1272 * The max length allowed in the input component 1273 * @return (String)handleGetMaxLength() 1274 */ 1275 public final String getMaxLength() 1276 { 1277 String maxLength38a = this.__maxLength38a; 1278 if (!this.__maxLength38aSet) 1279 { 1280 // maxLength has no pre constraints 1281 maxLength38a = handleGetMaxLength(); 1282 // maxLength has no post constraints 1283 this.__maxLength38a = maxLength38a; 1284 if (isMetafacadePropertyCachingEnabled()) 1285 { 1286 this.__maxLength38aSet = true; 1287 } 1288 } 1289 return maxLength38a; 1290 } 1291 1292 /** 1293 * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute#isEditable() 1294 * @return boolean 1295 */ 1296 protected abstract boolean handleIsEditable(); 1297 1298 private boolean __editable39a; 1299 private boolean __editable39aSet = false; 1300 1301 /** 1302 * Whether or not this attribute should be put in the view 1303 * @return (boolean)handleIsEditable() 1304 */ 1305 public final boolean isEditable() 1306 { 1307 boolean editable39a = this.__editable39a; 1308 if (!this.__editable39aSet) 1309 { 1310 // editable has no pre constraints 1311 editable39a = handleIsEditable(); 1312 // editable has no post constraints 1313 this.__editable39a = editable39a; 1314 if (isMetafacadePropertyCachingEnabled()) 1315 { 1316 this.__editable39aSet = true; 1317 } 1318 } 1319 return editable39a; 1320 } 1321 1322 // ---------------- business methods ---------------------- 1323 1324 /** 1325 * Method to be implemented in descendants 1326 * TODO: Model Documentation for 1327 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.getValidatorArgs 1328 * @param validatorType 1329 * @return Collection 1330 */ 1331 protected abstract Collection handleGetValidatorArgs(String validatorType); 1332 1333 /** 1334 * TODO: Model Documentation for 1335 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.getValidatorArgs 1336 * @param validatorType String 1337 * TODO: Model Documentation for 1338 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAttribute.getValidatorArgs(validatorType) 1339 * @return handleGetValidatorArgs(validatorType) 1340 */ 1341 public Collection getValidatorArgs(String validatorType) 1342 { 1343 // getValidatorArgs has no pre constraints 1344 Collection returnValue = handleGetValidatorArgs(validatorType); 1345 // getValidatorArgs has no post constraints 1346 return returnValue; 1347 } 1348 1349 /** 1350 * Method to be implemented in descendants 1351 * Gets the unique id of this attribute on the form. 1352 * @param ownerParameter 1353 * @return String 1354 */ 1355 protected abstract String handleGetFormPropertyId(ParameterFacade ownerParameter); 1356 1357 /** 1358 * Gets the unique id of this attribute on the form. 1359 * @param ownerParameter ParameterFacade 1360 * The parameter that is the owner of this attribute. 1361 * @return handleGetFormPropertyId(ownerParameter) 1362 */ 1363 public String getFormPropertyId(ParameterFacade ownerParameter) 1364 { 1365 // getFormPropertyId has no pre constraints 1366 String returnValue = handleGetFormPropertyId(ownerParameter); 1367 // getFormPropertyId has no post constraints 1368 return returnValue; 1369 } 1370 1371 /** 1372 * Method to be implemented in descendants 1373 * Retrieves the name of the form property for this attribute by taking the name of the owner 1374 * property. 1375 * @param ownerParameter 1376 * @return String 1377 */ 1378 protected abstract String handleGetFormPropertyName(ParameterFacade ownerParameter); 1379 1380 /** 1381 * Retrieves the name of the form property for this attribute by taking the name of the owner 1382 * property. 1383 * @param ownerParameter ParameterFacade 1384 * The parent that is the owner of this parameter. 1385 * @return handleGetFormPropertyName(ownerParameter) 1386 */ 1387 public String getFormPropertyName(ParameterFacade ownerParameter) 1388 { 1389 // getFormPropertyName has no pre constraints 1390 String returnValue = handleGetFormPropertyName(ownerParameter); 1391 // getFormPropertyName has no post constraints 1392 return returnValue; 1393 } 1394 1395 /** 1396 * @return true 1397 * @see ManageableEntityAttribute 1398 */ 1399 public boolean isManageableEntityAttributeMetaType() 1400 { 1401 return true; 1402 } 1403 1404 /** 1405 * @return true 1406 * @see org.andromda.metafacades.uml.EntityAttribute 1407 */ 1408 public boolean isEntityAttributeMetaType() 1409 { 1410 return true; 1411 } 1412 1413 /** 1414 * @return true 1415 * @see org.andromda.metafacades.uml.AttributeFacade 1416 */ 1417 public boolean isAttributeFacadeMetaType() 1418 { 1419 return true; 1420 } 1421 1422 /** 1423 * @return true 1424 * @see ModelElementFacade 1425 */ 1426 public boolean isModelElementFacadeMetaType() 1427 { 1428 return true; 1429 } 1430 1431 // ----------- delegates to ManageableEntityAttribute ------------ 1432 /** 1433 * Searches the given feature for the specified tag. 1434 * If the follow boolean is set to true then the search will continue from the class attribute 1435 * to the class itself and then up the class hierarchy. 1436 * @see org.andromda.metafacades.uml.AttributeFacade#findTaggedValue(String name, boolean follow) 1437 */ 1438 public Object findTaggedValue(String name, boolean follow) 1439 { 1440 return this.getSuperManageableEntityAttribute().findTaggedValue(name, follow); 1441 } 1442 1443 /** 1444 * The default value of the attribute. This is the value given if no value is defined. 1445 * @see org.andromda.metafacades.uml.AttributeFacade#getDefaultValue() 1446 */ 1447 public String getDefaultValue() 1448 { 1449 return this.getSuperManageableEntityAttribute().getDefaultValue(); 1450 } 1451 1452 /** 1453 * If the attribute is an enumeration literal this represents the owning enumeration. Can be 1454 * empty. 1455 * @see org.andromda.metafacades.uml.AttributeFacade#getEnumeration() 1456 */ 1457 public EnumerationFacade getEnumeration() 1458 { 1459 return this.getSuperManageableEntityAttribute().getEnumeration(); 1460 } 1461 1462 /** 1463 * Returns the enumeration literal parameters defined by tagged value as a comma separated list. 1464 * @see org.andromda.metafacades.uml.AttributeFacade#getEnumerationLiteralParameters() 1465 */ 1466 public String getEnumerationLiteralParameters() 1467 { 1468 return this.getSuperManageableEntityAttribute().getEnumerationLiteralParameters(); 1469 } 1470 1471 /** 1472 * The value for this attribute if it is an enumeration literal, null otherwise. The default 1473 * value is returned as a String if it has been specified, if it's not specified this 1474 * attribute's name is assumed. 1475 * @see org.andromda.metafacades.uml.AttributeFacade#getEnumerationValue() 1476 */ 1477 public String getEnumerationValue() 1478 { 1479 return this.getSuperManageableEntityAttribute().getEnumerationValue(); 1480 } 1481 1482 /** 1483 * The name of the accessor operation that would retrieve this attribute's value. 1484 * @see org.andromda.metafacades.uml.AttributeFacade#getGetterName() 1485 */ 1486 public String getGetterName() 1487 { 1488 return this.getSuperManageableEntityAttribute().getGetterName(); 1489 } 1490 1491 /** 1492 * The name of the type that is returned on the accessor and mutator operations, determined in 1493 * part by the multiplicity. 1494 * @see org.andromda.metafacades.uml.AttributeFacade#getGetterSetterTypeName() 1495 */ 1496 public String getGetterSetterTypeName() 1497 { 1498 return this.getSuperManageableEntityAttribute().getGetterSetterTypeName(); 1499 } 1500 1501 /** 1502 * the lower value for the multiplicity 1503 * -only applicable for UML2 1504 * @see org.andromda.metafacades.uml.AttributeFacade#getLower() 1505 */ 1506 public int getLower() 1507 { 1508 return this.getSuperManageableEntityAttribute().getLower(); 1509 } 1510 1511 /** 1512 * Gets the classifier who is the owner of the attributes. 1513 * @see org.andromda.metafacades.uml.AttributeFacade#getOwner() 1514 */ 1515 public ClassifierFacade getOwner() 1516 { 1517 return this.getSuperManageableEntityAttribute().getOwner(); 1518 } 1519 1520 /** 1521 * The name of the mutator operation that would retrieve this attribute's value. 1522 * @see org.andromda.metafacades.uml.AttributeFacade#getSetterName() 1523 */ 1524 public String getSetterName() 1525 { 1526 return this.getSuperManageableEntityAttribute().getSetterName(); 1527 } 1528 1529 /** 1530 * The classifier owning this attribute. 1531 * @see org.andromda.metafacades.uml.AttributeFacade#getType() 1532 */ 1533 public ClassifierFacade getType() 1534 { 1535 return this.getSuperManageableEntityAttribute().getType(); 1536 } 1537 1538 /** 1539 * the upper value for the multiplicity (will be -1 for *) 1540 * -only applicable for UML2 1541 * @see org.andromda.metafacades.uml.AttributeFacade#getUpper() 1542 */ 1543 public int getUpper() 1544 { 1545 return this.getSuperManageableEntityAttribute().getUpper(); 1546 } 1547 1548 /** 1549 * True if this attribute can only be set. 1550 * @see org.andromda.metafacades.uml.AttributeFacade#isAddOnly() 1551 */ 1552 public boolean isAddOnly() 1553 { 1554 return this.getSuperManageableEntityAttribute().isAddOnly(); 1555 } 1556 1557 /** 1558 * True if this attribute can be modified. 1559 * @see org.andromda.metafacades.uml.AttributeFacade#isChangeable() 1560 */ 1561 public boolean isChangeable() 1562 { 1563 return this.getSuperManageableEntityAttribute().isChangeable(); 1564 } 1565 1566 /** 1567 * Indicates if the default value is present. 1568 * @see org.andromda.metafacades.uml.AttributeFacade#isDefaultValuePresent() 1569 */ 1570 public boolean isDefaultValuePresent() 1571 { 1572 return this.getSuperManageableEntityAttribute().isDefaultValuePresent(); 1573 } 1574 1575 /** 1576 * If the attribute is derived (its value is computed). UML2 only. UML14 always returns false. 1577 * Default=false. 1578 * @see org.andromda.metafacades.uml.AttributeFacade#isDerived() 1579 */ 1580 public boolean isDerived() 1581 { 1582 return this.getSuperManageableEntityAttribute().isDerived(); 1583 } 1584 1585 /** 1586 * True if this attribute is owned by an enumeration. 1587 * @see org.andromda.metafacades.uml.AttributeFacade#isEnumerationLiteral() 1588 */ 1589 public boolean isEnumerationLiteral() 1590 { 1591 return this.getSuperManageableEntityAttribute().isEnumerationLiteral(); 1592 } 1593 1594 /** 1595 * Returns true if enumeration literal parameters exist (defined by tagged value) for the 1596 * literal. 1597 * @see org.andromda.metafacades.uml.AttributeFacade#isEnumerationLiteralParametersExist() 1598 */ 1599 public boolean isEnumerationLiteralParametersExist() 1600 { 1601 return this.getSuperManageableEntityAttribute().isEnumerationLiteralParametersExist(); 1602 } 1603 1604 /** 1605 * True if this attribute is owned by an enumeration but is defined as a member variable (NOT a 1606 * literal). 1607 * @see org.andromda.metafacades.uml.AttributeFacade#isEnumerationMember() 1608 */ 1609 public boolean isEnumerationMember() 1610 { 1611 return this.getSuperManageableEntityAttribute().isEnumerationMember(); 1612 } 1613 1614 /** 1615 * IsLeaf property in the operation. If true, operation is final, cannot be extended or 1616 * implemented by a descendant. 1617 * @see org.andromda.metafacades.uml.AttributeFacade#isLeaf() 1618 */ 1619 public boolean isLeaf() 1620 { 1621 return this.getSuperManageableEntityAttribute().isLeaf(); 1622 } 1623 1624 /** 1625 * Whether or not this attribute has a multiplicity greater than 1. 1626 * @see org.andromda.metafacades.uml.AttributeFacade#isMany() 1627 */ 1628 public boolean isMany() 1629 { 1630 return this.getSuperManageableEntityAttribute().isMany(); 1631 } 1632 1633 /** 1634 * Indicates whether or not the attributes are ordered (if multiplicity is greater than 1). 1635 * @see org.andromda.metafacades.uml.AttributeFacade#isOrdered() 1636 */ 1637 public boolean isOrdered() 1638 { 1639 return this.getSuperManageableEntityAttribute().isOrdered(); 1640 } 1641 1642 /** 1643 * Whether or not this attribute can be modified. 1644 * @see org.andromda.metafacades.uml.AttributeFacade#isReadOnly() 1645 */ 1646 public boolean isReadOnly() 1647 { 1648 return this.getSuperManageableEntityAttribute().isReadOnly(); 1649 } 1650 1651 /** 1652 * Whether or not the multiplicity of this attribute is 1. 1653 * @see org.andromda.metafacades.uml.AttributeFacade#isRequired() 1654 */ 1655 public boolean isRequired() 1656 { 1657 return this.getSuperManageableEntityAttribute().isRequired(); 1658 } 1659 1660 /** 1661 * Indicates if this attribute is 'static', meaning it has a classifier scope. 1662 * @see org.andromda.metafacades.uml.AttributeFacade#isStatic() 1663 */ 1664 public boolean isStatic() 1665 { 1666 return this.getSuperManageableEntityAttribute().isStatic(); 1667 } 1668 1669 /** 1670 * If the attribute is unique within the Collection type. UML2 only. UML14 always returns false. 1671 * Unique+Ordered determines the implementation Collection type. Default=false. 1672 * @see org.andromda.metafacades.uml.AttributeFacade#isUnique() 1673 */ 1674 public boolean isUnique() 1675 { 1676 return this.getSuperManageableEntityAttribute().isUnique(); 1677 } 1678 1679 /** 1680 * The name of the index to create on a column that persists the entity attribute. 1681 * @see org.andromda.metafacades.uml.EntityAttribute#getColumnIndex() 1682 */ 1683 public String getColumnIndex() 1684 { 1685 return this.getSuperManageableEntityAttribute().getColumnIndex(); 1686 } 1687 1688 /** 1689 * The length of the column that persists this entity attribute. 1690 * @see org.andromda.metafacades.uml.EntityAttribute#getColumnLength() 1691 */ 1692 public String getColumnLength() 1693 { 1694 return this.getSuperManageableEntityAttribute().getColumnLength(); 1695 } 1696 1697 /** 1698 * The name of the table column to which this entity is mapped. 1699 * @see org.andromda.metafacades.uml.EntityAttribute#getColumnName() 1700 */ 1701 public String getColumnName() 1702 { 1703 return this.getSuperManageableEntityAttribute().getColumnName(); 1704 } 1705 1706 /** 1707 * The PIM to language specific mappings for JDBC. 1708 * @see org.andromda.metafacades.uml.EntityAttribute#getJdbcMappings() 1709 */ 1710 public TypeMappings getJdbcMappings() 1711 { 1712 return this.getSuperManageableEntityAttribute().getJdbcMappings(); 1713 } 1714 1715 /** 1716 * The JDBC type for this entity attribute. 1717 * @see org.andromda.metafacades.uml.EntityAttribute#getJdbcType() 1718 */ 1719 public String getJdbcType() 1720 { 1721 return this.getSuperManageableEntityAttribute().getJdbcType(); 1722 } 1723 1724 /** 1725 * The SQL mappings (i.e. the mappings which provide PIM to SQL mappings). 1726 * @see org.andromda.metafacades.uml.EntityAttribute#getSqlMappings() 1727 */ 1728 public TypeMappings getSqlMappings() 1729 { 1730 return this.getSuperManageableEntityAttribute().getSqlMappings(); 1731 } 1732 1733 /** 1734 * The SQL type for this attribute. 1735 * @see org.andromda.metafacades.uml.EntityAttribute#getSqlType() 1736 */ 1737 public String getSqlType() 1738 { 1739 return this.getSuperManageableEntityAttribute().getSqlType(); 1740 } 1741 1742 /** 1743 * The name of the unique-key that this unique attribute belongs 1744 * @see org.andromda.metafacades.uml.EntityAttribute#getUniqueGroup() 1745 */ 1746 public String getUniqueGroup() 1747 { 1748 return this.getSuperManageableEntityAttribute().getUniqueGroup(); 1749 } 1750 1751 /** 1752 * True if this attribute is an identifier for its entity. 1753 * @see org.andromda.metafacades.uml.EntityAttribute#isIdentifier() 1754 */ 1755 public boolean isIdentifier() 1756 { 1757 return this.getSuperManageableEntityAttribute().isIdentifier(); 1758 } 1759 1760 /** 1761 * Indicates this attribute should be ignored by the persistence layer. 1762 * @see org.andromda.metafacades.uml.EntityAttribute#isTransient() 1763 */ 1764 public boolean isTransient() 1765 { 1766 return this.getSuperManageableEntityAttribute().isTransient(); 1767 } 1768 1769 /** 1770 * Whether or not this attribute should be displayed. 1771 * @see ManageableEntityAttribute#isDisplay() 1772 */ 1773 public boolean isDisplay() 1774 { 1775 return this.getSuperManageableEntityAttribute().isDisplay(); 1776 } 1777 1778 /** 1779 * Whether or not this attribute can be read in a call isolated from the rest (for example when 1780 * downloading binary fields). 1781 * @see ManageableEntityAttribute#isManageableGetterAvailable() 1782 */ 1783 public boolean isManageableGetterAvailable() 1784 { 1785 return this.getSuperManageableEntityAttribute().isManageableGetterAvailable(); 1786 } 1787 1788 /** 1789 * Copies all tagged values from the given ModelElementFacade to this model element facade. 1790 * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element) 1791 */ 1792 public void copyTaggedValues(ModelElementFacade element) 1793 { 1794 this.getSuperManageableEntityAttribute().copyTaggedValues(element); 1795 } 1796 1797 /** 1798 * Finds the tagged value with the specified 'tagName'. In case there are more values the first 1799 * one found will be returned. 1800 * @see ModelElementFacade#findTaggedValue(String tagName) 1801 */ 1802 public Object findTaggedValue(String tagName) 1803 { 1804 return this.getSuperManageableEntityAttribute().findTaggedValue(tagName); 1805 } 1806 1807 /** 1808 * Returns all the values for the tagged value with the specified name. The returned collection 1809 * will contains only String instances, or will be empty. Never null. 1810 * @see ModelElementFacade#findTaggedValues(String tagName) 1811 */ 1812 public Collection<Object> findTaggedValues(String tagName) 1813 { 1814 return this.getSuperManageableEntityAttribute().findTaggedValues(tagName); 1815 } 1816 1817 /** 1818 * Returns the fully qualified name of the model element. The fully qualified name includes 1819 * complete package qualified name of the underlying model element. The templates parameter will 1820 * be replaced by the correct one given the binding relation of the parameter to this element. 1821 * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement) 1822 */ 1823 public String getBindedFullyQualifiedName(ModelElementFacade bindedElement) 1824 { 1825 return this.getSuperManageableEntityAttribute().getBindedFullyQualifiedName(bindedElement); 1826 } 1827 1828 /** 1829 * Gets all constraints belonging to the model element. 1830 * @see ModelElementFacade#getConstraints() 1831 */ 1832 public Collection<ConstraintFacade> getConstraints() 1833 { 1834 return this.getSuperManageableEntityAttribute().getConstraints(); 1835 } 1836 1837 /** 1838 * Returns the constraints of the argument kind that have been placed onto this model. Typical 1839 * kinds are "inv", "pre" and "post". Other kinds are possible. 1840 * @see ModelElementFacade#getConstraints(String kind) 1841 */ 1842 public Collection<ConstraintFacade> getConstraints(String kind) 1843 { 1844 return this.getSuperManageableEntityAttribute().getConstraints(kind); 1845 } 1846 1847 /** 1848 * Gets the documentation for the model element, The indent argument is prefixed to each line. 1849 * By default this method wraps lines after 64 characters. 1850 * This method is equivalent to <code>getDocumentation(indent, 64)</code>. 1851 * @see ModelElementFacade#getDocumentation(String indent) 1852 */ 1853 public String getDocumentation(String indent) 1854 { 1855 return this.getSuperManageableEntityAttribute().getDocumentation(indent); 1856 } 1857 1858 /** 1859 * This method returns the documentation for this model element, with the lines wrapped after 1860 * the specified number of characters, values of less than 1 will indicate no line wrapping is 1861 * required. By default paragraphs are returned as HTML. 1862 * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>. 1863 * @see ModelElementFacade#getDocumentation(String indent, int lineLength) 1864 */ 1865 public String getDocumentation(String indent, int lineLength) 1866 { 1867 return this.getSuperManageableEntityAttribute().getDocumentation(indent, lineLength); 1868 } 1869 1870 /** 1871 * This method returns the documentation for this model element, with the lines wrapped after 1872 * the specified number of characters, values of less than 1 will indicate no line wrapping is 1873 * required. HTML style determines if HTML Escaping is applied. 1874 * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle) 1875 */ 1876 public String getDocumentation(String indent, int lineLength, boolean htmlStyle) 1877 { 1878 return this.getSuperManageableEntityAttribute().getDocumentation(indent, lineLength, htmlStyle); 1879 } 1880 1881 /** 1882 * The fully qualified name of this model element. 1883 * @see ModelElementFacade#getFullyQualifiedName() 1884 */ 1885 public String getFullyQualifiedName() 1886 { 1887 return this.getSuperManageableEntityAttribute().getFullyQualifiedName(); 1888 } 1889 1890 /** 1891 * Returns the fully qualified name of the model element. The fully qualified name includes 1892 * complete package qualified name of the underlying model element. If modelName is true, then 1893 * the original name of the model element (the name contained within the model) will be the name 1894 * returned, otherwise a name from a language mapping will be returned. 1895 * @see ModelElementFacade#getFullyQualifiedName(boolean modelName) 1896 */ 1897 public String getFullyQualifiedName(boolean modelName) 1898 { 1899 return this.getSuperManageableEntityAttribute().getFullyQualifiedName(modelName); 1900 } 1901 1902 /** 1903 * Returns the fully qualified name as a path, the returned value always starts with out a slash 1904 * '/'. 1905 * @see ModelElementFacade#getFullyQualifiedNamePath() 1906 */ 1907 public String getFullyQualifiedNamePath() 1908 { 1909 return this.getSuperManageableEntityAttribute().getFullyQualifiedNamePath(); 1910 } 1911 1912 /** 1913 * Gets the unique identifier of the underlying model element. 1914 * @see ModelElementFacade#getId() 1915 */ 1916 public String getId() 1917 { 1918 return this.getSuperManageableEntityAttribute().getId(); 1919 } 1920 1921 /** 1922 * UML2: Retrieves the keywords for this element. Used to modify implementation properties which 1923 * are not represented by other properties, i.e. native, transient, volatile, synchronized, 1924 * (added annotations) override, deprecated. Can also be used to suppress compiler warnings: 1925 * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require 1926 * JDK5 compiler level. 1927 * @see ModelElementFacade#getKeywords() 1928 */ 1929 public Collection<String> getKeywords() 1930 { 1931 return this.getSuperManageableEntityAttribute().getKeywords(); 1932 } 1933 1934 /** 1935 * UML2: Retrieves a localized label for this named element. 1936 * @see ModelElementFacade#getLabel() 1937 */ 1938 public String getLabel() 1939 { 1940 return this.getSuperManageableEntityAttribute().getLabel(); 1941 } 1942 1943 /** 1944 * The language mappings that have been set for this model element. 1945 * @see ModelElementFacade#getLanguageMappings() 1946 */ 1947 public TypeMappings getLanguageMappings() 1948 { 1949 return this.getSuperManageableEntityAttribute().getLanguageMappings(); 1950 } 1951 1952 /** 1953 * Return the model containing this model element (multiple models may be loaded and processed 1954 * at the same time). 1955 * @see ModelElementFacade#getModel() 1956 */ 1957 public ModelFacade getModel() 1958 { 1959 return this.getSuperManageableEntityAttribute().getModel(); 1960 } 1961 1962 /** 1963 * The name of the model element. 1964 * @see ModelElementFacade#getName() 1965 */ 1966 public String getName() 1967 { 1968 return this.getSuperManageableEntityAttribute().getName(); 1969 } 1970 1971 /** 1972 * Gets the package to which this model element belongs. 1973 * @see ModelElementFacade#getPackage() 1974 */ 1975 public ModelElementFacade getPackage() 1976 { 1977 return this.getSuperManageableEntityAttribute().getPackage(); 1978 } 1979 1980 /** 1981 * The name of this model element's package. 1982 * @see ModelElementFacade#getPackageName() 1983 */ 1984 public String getPackageName() 1985 { 1986 return this.getSuperManageableEntityAttribute().getPackageName(); 1987 } 1988 1989 /** 1990 * Gets the package name (optionally providing the ability to retrieve the model name and not 1991 * the mapped name). 1992 * @see ModelElementFacade#getPackageName(boolean modelName) 1993 */ 1994 public String getPackageName(boolean modelName) 1995 { 1996 return this.getSuperManageableEntityAttribute().getPackageName(modelName); 1997 } 1998 1999 /** 2000 * Returns the package as a path, the returned value always starts with out a slash '/'. 2001 * @see ModelElementFacade#getPackagePath() 2002 */ 2003 public String getPackagePath() 2004 { 2005 return this.getSuperManageableEntityAttribute().getPackagePath(); 2006 } 2007 2008 /** 2009 * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the 2010 * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from 2011 * the names of the containing namespaces starting at the root of the hierarchy and ending with 2012 * the name of the NamedElement itself. 2013 * @see ModelElementFacade#getQualifiedName() 2014 */ 2015 public String getQualifiedName() 2016 { 2017 return this.getSuperManageableEntityAttribute().getQualifiedName(); 2018 } 2019 2020 /** 2021 * Gets the root package for the model element. 2022 * @see ModelElementFacade#getRootPackage() 2023 */ 2024 public PackageFacade getRootPackage() 2025 { 2026 return this.getSuperManageableEntityAttribute().getRootPackage(); 2027 } 2028 2029 /** 2030 * Gets the dependencies for which this model element is the source. 2031 * @see ModelElementFacade#getSourceDependencies() 2032 */ 2033 public Collection<DependencyFacade> getSourceDependencies() 2034 { 2035 return this.getSuperManageableEntityAttribute().getSourceDependencies(); 2036 } 2037 2038 /** 2039 * If this model element is the context of an activity graph, this represents that activity 2040 * graph. 2041 * @see ModelElementFacade#getStateMachineContext() 2042 */ 2043 public StateMachineFacade getStateMachineContext() 2044 { 2045 return this.getSuperManageableEntityAttribute().getStateMachineContext(); 2046 } 2047 2048 /** 2049 * The collection of ALL stereotype names for this model element. 2050 * @see ModelElementFacade#getStereotypeNames() 2051 */ 2052 public Collection<String> getStereotypeNames() 2053 { 2054 return this.getSuperManageableEntityAttribute().getStereotypeNames(); 2055 } 2056 2057 /** 2058 * Gets all stereotypes for this model element. 2059 * @see ModelElementFacade#getStereotypes() 2060 */ 2061 public Collection<StereotypeFacade> getStereotypes() 2062 { 2063 return this.getSuperManageableEntityAttribute().getStereotypes(); 2064 } 2065 2066 /** 2067 * Return the TaggedValues associated with this model element, under all stereotypes. 2068 * @see ModelElementFacade#getTaggedValues() 2069 */ 2070 public Collection<TaggedValueFacade> getTaggedValues() 2071 { 2072 return this.getSuperManageableEntityAttribute().getTaggedValues(); 2073 } 2074 2075 /** 2076 * Gets the dependencies for which this model element is the target. 2077 * @see ModelElementFacade#getTargetDependencies() 2078 */ 2079 public Collection<DependencyFacade> getTargetDependencies() 2080 { 2081 return this.getSuperManageableEntityAttribute().getTargetDependencies(); 2082 } 2083 2084 /** 2085 * Get the template parameter for this model element having the parameterName 2086 * @see ModelElementFacade#getTemplateParameter(String parameterName) 2087 */ 2088 public Object getTemplateParameter(String parameterName) 2089 { 2090 return this.getSuperManageableEntityAttribute().getTemplateParameter(parameterName); 2091 } 2092 2093 /** 2094 * Get the template parameters for this model element 2095 * @see ModelElementFacade#getTemplateParameters() 2096 */ 2097 public Collection<TemplateParameterFacade> getTemplateParameters() 2098 { 2099 return this.getSuperManageableEntityAttribute().getTemplateParameters(); 2100 } 2101 2102 /** 2103 * The visibility (i.e. public, private, protected or package) of the model element, will 2104 * attempt a lookup for these values in the language mappings (if any). 2105 * @see ModelElementFacade#getVisibility() 2106 */ 2107 public String getVisibility() 2108 { 2109 return this.getSuperManageableEntityAttribute().getVisibility(); 2110 } 2111 2112 /** 2113 * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance 2114 * is taken into account when searching for the stereotype), false otherwise. 2115 * @see ModelElementFacade#hasExactStereotype(String stereotypeName) 2116 */ 2117 public boolean hasExactStereotype(String stereotypeName) 2118 { 2119 return this.getSuperManageableEntityAttribute().hasExactStereotype(stereotypeName); 2120 } 2121 2122 /** 2123 * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma, 2124 * pipe, semicolon, or << >> 2125 * @see ModelElementFacade#hasKeyword(String keywordName) 2126 */ 2127 public boolean hasKeyword(String keywordName) 2128 { 2129 return this.getSuperManageableEntityAttribute().hasKeyword(keywordName); 2130 } 2131 2132 /** 2133 * Returns true if the model element has the specified stereotype. If the stereotype itself 2134 * does not match, then a search will be made up the stereotype inheritance hierarchy, and if 2135 * one of the stereotype's ancestors has a matching name this method will return true, false 2136 * otherwise. 2137 * For example, if we have a certain stereotype called <<exception>> and a model element has a 2138 * stereotype called <<applicationException>> which extends <<exception>>, when calling this 2139 * method with 'stereotypeName' defined as 'exception' the method would return true since 2140 * <<applicationException>> inherits from <<exception>>. If you want to check if the model 2141 * element has the exact stereotype, then use the method 'hasExactStereotype' instead. 2142 * @see ModelElementFacade#hasStereotype(String stereotypeName) 2143 */ 2144 public boolean hasStereotype(String stereotypeName) 2145 { 2146 return this.getSuperManageableEntityAttribute().hasStereotype(stereotypeName); 2147 } 2148 2149 /** 2150 * True if there are target dependencies from this element that are instances of BindingFacade. 2151 * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies. 2152 * @see ModelElementFacade#isBindingDependenciesPresent() 2153 */ 2154 public boolean isBindingDependenciesPresent() 2155 { 2156 return this.getSuperManageableEntityAttribute().isBindingDependenciesPresent(); 2157 } 2158 2159 /** 2160 * Indicates if any constraints are present on this model element. 2161 * @see ModelElementFacade#isConstraintsPresent() 2162 */ 2163 public boolean isConstraintsPresent() 2164 { 2165 return this.getSuperManageableEntityAttribute().isConstraintsPresent(); 2166 } 2167 2168 /** 2169 * Indicates if any documentation is present on this model element. 2170 * @see ModelElementFacade#isDocumentationPresent() 2171 */ 2172 public boolean isDocumentationPresent() 2173 { 2174 return this.getSuperManageableEntityAttribute().isDocumentationPresent(); 2175 } 2176 2177 /** 2178 * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript. 2179 * @see ModelElementFacade#isReservedWord() 2180 */ 2181 public boolean isReservedWord() 2182 { 2183 return this.getSuperManageableEntityAttribute().isReservedWord(); 2184 } 2185 2186 /** 2187 * True is there are template parameters on this model element. For UML2, applies to Class, 2188 * Operation, Property, and Parameter. 2189 * @see ModelElementFacade#isTemplateParametersPresent() 2190 */ 2191 public boolean isTemplateParametersPresent() 2192 { 2193 return this.getSuperManageableEntityAttribute().isTemplateParametersPresent(); 2194 } 2195 2196 /** 2197 * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++, 2198 * JavaScript. Contains no spaces, special characters etc. Constraint always applied on 2199 * Enumerations and Interfaces, optionally applies on other model elements. 2200 * @see ModelElementFacade#isValidIdentifierName() 2201 */ 2202 public boolean isValidIdentifierName() 2203 { 2204 return this.getSuperManageableEntityAttribute().isValidIdentifierName(); 2205 } 2206 2207 /** 2208 * Searches for the constraint with the specified 'name' on this model element, and if found 2209 * translates it using the specified 'translation' from a translation library discovered by the 2210 * framework. 2211 * @see ModelElementFacade#translateConstraint(String name, String translation) 2212 */ 2213 public String translateConstraint(String name, String translation) 2214 { 2215 return this.getSuperManageableEntityAttribute().translateConstraint(name, translation); 2216 } 2217 2218 /** 2219 * Translates all constraints belonging to this model element with the given 'translation'. 2220 * @see ModelElementFacade#translateConstraints(String translation) 2221 */ 2222 public String[] translateConstraints(String translation) 2223 { 2224 return this.getSuperManageableEntityAttribute().translateConstraints(translation); 2225 } 2226 2227 /** 2228 * Translates the constraints of the specified 'kind' belonging to this model element. 2229 * @see ModelElementFacade#translateConstraints(String kind, String translation) 2230 */ 2231 public String[] translateConstraints(String kind, String translation) 2232 { 2233 return this.getSuperManageableEntityAttribute().translateConstraints(kind, translation); 2234 } 2235 2236 /** 2237 * @see org.andromda.core.metafacade.MetafacadeBase#initialize() 2238 */ 2239 @Override 2240 public void initialize() 2241 { 2242 this.getSuperManageableEntityAttribute().initialize(); 2243 } 2244 2245 /** 2246 * @return Object getSuperManageableEntityAttribute().getValidationOwner() 2247 * @see org.andromda.core.metafacade.MetafacadeBase#getValidationOwner() 2248 */ 2249 @Override 2250 public Object getValidationOwner() 2251 { 2252 Object owner = this.getSuperManageableEntityAttribute().getValidationOwner(); 2253 return owner; 2254 } 2255 2256 /** 2257 * @return String getSuperManageableEntityAttribute().getValidationName() 2258 * @see org.andromda.core.metafacade.MetafacadeBase#getValidationName() 2259 */ 2260 @Override 2261 public String getValidationName() 2262 { 2263 String name = this.getSuperManageableEntityAttribute().getValidationName(); 2264 return name; 2265 } 2266 2267 /** 2268 * @param validationMessages Collection<ModelValidationMessage> 2269 * @see org.andromda.core.metafacade.MetafacadeBase#validateInvariants(Collection validationMessages) 2270 */ 2271 @Override 2272 public void validateInvariants(Collection<ModelValidationMessage> validationMessages) 2273 { 2274 this.getSuperManageableEntityAttribute().validateInvariants(validationMessages); 2275 } 2276 2277 /** 2278 * The property that stores the name of the metafacade. 2279 */ 2280 private static final String NAME_PROPERTY = "name"; 2281 private static final String FQNAME_PROPERTY = "fullyQualifiedName"; 2282 2283 /** 2284 * @see Object#toString() 2285 */ 2286 @Override 2287 public String toString() 2288 { 2289 final StringBuilder toString = new StringBuilder(this.getClass().getName()); 2290 toString.append("["); 2291 try 2292 { 2293 toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY)); 2294 } 2295 catch (final Throwable tryAgain) 2296 { 2297 try 2298 { 2299 toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY)); 2300 } 2301 catch (final Throwable ignore) 2302 { 2303 // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property 2304 } 2305 } 2306 toString.append("]"); 2307 return toString.toString(); 2308 } 2309}