001// license-header java merge-point 002// 003// Attention: generated code (by MetafacadeLogic.vsl) - do not modify! 004// 005package org.andromda.cartridges.jsf.metafacades; 006 007import java.util.Collection; 008import 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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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.jsf.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 // ---------------- business methods ---------------------- 1293 1294 /** 1295 * Method to be implemented in descendants 1296 * TODO: Model Documentation for 1297 * org.andromda.cartridges.jsf.metafacades.JSFManageableEntityAttribute.getValidatorArgs 1298 * @param validatorType 1299 * @return Collection 1300 */ 1301 protected abstract Collection handleGetValidatorArgs(String validatorType); 1302 1303 /** 1304 * TODO: Model Documentation for 1305 * org.andromda.cartridges.jsf.metafacades.JSFManageableEntityAttribute.getValidatorArgs 1306 * @param validatorType String 1307 * TODO: Model Documentation for 1308 * org.andromda.cartridges.jsf.metafacades.JSFManageableEntityAttribute.getValidatorArgs(validatorType) 1309 * @return handleGetValidatorArgs(validatorType) 1310 */ 1311 public Collection getValidatorArgs(String validatorType) 1312 { 1313 // getValidatorArgs has no pre constraints 1314 Collection returnValue = handleGetValidatorArgs(validatorType); 1315 // getValidatorArgs has no post constraints 1316 return returnValue; 1317 } 1318 1319 /** 1320 * Method to be implemented in descendants 1321 * Gets the unique id of this attribute on the form. 1322 * @param ownerParameter 1323 * @return String 1324 */ 1325 protected abstract String handleGetFormPropertyId(ParameterFacade ownerParameter); 1326 1327 /** 1328 * Gets the unique id of this attribute on the form. 1329 * @param ownerParameter ParameterFacade 1330 * The parameter that is the owner of this attribute. 1331 * @return handleGetFormPropertyId(ownerParameter) 1332 */ 1333 public String getFormPropertyId(ParameterFacade ownerParameter) 1334 { 1335 // getFormPropertyId has no pre constraints 1336 String returnValue = handleGetFormPropertyId(ownerParameter); 1337 // getFormPropertyId has no post constraints 1338 return returnValue; 1339 } 1340 1341 /** 1342 * Method to be implemented in descendants 1343 * Retrieves the name of the form property for this attribute by taking the name of the owner 1344 * property. 1345 * @param ownerParameter 1346 * @return String 1347 */ 1348 protected abstract String handleGetFormPropertyName(ParameterFacade ownerParameter); 1349 1350 /** 1351 * Retrieves the name of the form property for this attribute by taking the name of the owner 1352 * property. 1353 * @param ownerParameter ParameterFacade 1354 * The parent that is the owner of this parameter. 1355 * @return handleGetFormPropertyName(ownerParameter) 1356 */ 1357 public String getFormPropertyName(ParameterFacade ownerParameter) 1358 { 1359 // getFormPropertyName has no pre constraints 1360 String returnValue = handleGetFormPropertyName(ownerParameter); 1361 // getFormPropertyName has no post constraints 1362 return returnValue; 1363 } 1364 1365 /** 1366 * @return true 1367 * @see ManageableEntityAttribute 1368 */ 1369 public boolean isManageableEntityAttributeMetaType() 1370 { 1371 return true; 1372 } 1373 1374 /** 1375 * @return true 1376 * @see org.andromda.metafacades.uml.EntityAttribute 1377 */ 1378 public boolean isEntityAttributeMetaType() 1379 { 1380 return true; 1381 } 1382 1383 /** 1384 * @return true 1385 * @see org.andromda.metafacades.uml.AttributeFacade 1386 */ 1387 public boolean isAttributeFacadeMetaType() 1388 { 1389 return true; 1390 } 1391 1392 /** 1393 * @return true 1394 * @see ModelElementFacade 1395 */ 1396 public boolean isModelElementFacadeMetaType() 1397 { 1398 return true; 1399 } 1400 1401 // ----------- delegates to ManageableEntityAttribute ------------ 1402 /** 1403 * Searches the given feature for the specified tag. 1404 * If the follow boolean is set to true then the search will continue from the class attribute 1405 * to the class itself and then up the class hierarchy. 1406 * @see org.andromda.metafacades.uml.AttributeFacade#findTaggedValue(String name, boolean follow) 1407 */ 1408 public Object findTaggedValue(String name, boolean follow) 1409 { 1410 return this.getSuperManageableEntityAttribute().findTaggedValue(name, follow); 1411 } 1412 1413 /** 1414 * The default value of the attribute. This is the value given if no value is defined. 1415 * @see org.andromda.metafacades.uml.AttributeFacade#getDefaultValue() 1416 */ 1417 public String getDefaultValue() 1418 { 1419 return this.getSuperManageableEntityAttribute().getDefaultValue(); 1420 } 1421 1422 /** 1423 * If the attribute is an enumeration literal this represents the owning enumeration. Can be 1424 * empty. 1425 * @see org.andromda.metafacades.uml.AttributeFacade#getEnumeration() 1426 */ 1427 public EnumerationFacade getEnumeration() 1428 { 1429 return this.getSuperManageableEntityAttribute().getEnumeration(); 1430 } 1431 1432 /** 1433 * Returns the enumeration literal parameters defined by tagged value as a comma separated list. 1434 * @see org.andromda.metafacades.uml.AttributeFacade#getEnumerationLiteralParameters() 1435 */ 1436 public String getEnumerationLiteralParameters() 1437 { 1438 return this.getSuperManageableEntityAttribute().getEnumerationLiteralParameters(); 1439 } 1440 1441 /** 1442 * The value for this attribute if it is an enumeration literal, null otherwise. The default 1443 * value is returned as a String if it has been specified, if it's not specified this 1444 * attribute's name is assumed. 1445 * @see org.andromda.metafacades.uml.AttributeFacade#getEnumerationValue() 1446 */ 1447 public String getEnumerationValue() 1448 { 1449 return this.getSuperManageableEntityAttribute().getEnumerationValue(); 1450 } 1451 1452 /** 1453 * The name of the accessor operation that would retrieve this attribute's value. 1454 * @see org.andromda.metafacades.uml.AttributeFacade#getGetterName() 1455 */ 1456 public String getGetterName() 1457 { 1458 return this.getSuperManageableEntityAttribute().getGetterName(); 1459 } 1460 1461 /** 1462 * The name of the type that is returned on the accessor and mutator operations, determined in 1463 * part by the multiplicity. 1464 * @see org.andromda.metafacades.uml.AttributeFacade#getGetterSetterTypeName() 1465 */ 1466 public String getGetterSetterTypeName() 1467 { 1468 return this.getSuperManageableEntityAttribute().getGetterSetterTypeName(); 1469 } 1470 1471 /** 1472 * the lower value for the multiplicity 1473 * -only applicable for UML2 1474 * @see org.andromda.metafacades.uml.AttributeFacade#getLower() 1475 */ 1476 public int getLower() 1477 { 1478 return this.getSuperManageableEntityAttribute().getLower(); 1479 } 1480 1481 /** 1482 * Gets the classifier who is the owner of the attributes. 1483 * @see org.andromda.metafacades.uml.AttributeFacade#getOwner() 1484 */ 1485 public ClassifierFacade getOwner() 1486 { 1487 return this.getSuperManageableEntityAttribute().getOwner(); 1488 } 1489 1490 /** 1491 * The name of the mutator operation that would retrieve this attribute's value. 1492 * @see org.andromda.metafacades.uml.AttributeFacade#getSetterName() 1493 */ 1494 public String getSetterName() 1495 { 1496 return this.getSuperManageableEntityAttribute().getSetterName(); 1497 } 1498 1499 /** 1500 * The classifier owning this attribute. 1501 * @see org.andromda.metafacades.uml.AttributeFacade#getType() 1502 */ 1503 public ClassifierFacade getType() 1504 { 1505 return this.getSuperManageableEntityAttribute().getType(); 1506 } 1507 1508 /** 1509 * the upper value for the multiplicity (will be -1 for *) 1510 * -only applicable for UML2 1511 * @see org.andromda.metafacades.uml.AttributeFacade#getUpper() 1512 */ 1513 public int getUpper() 1514 { 1515 return this.getSuperManageableEntityAttribute().getUpper(); 1516 } 1517 1518 /** 1519 * True if this attribute can only be set. 1520 * @see org.andromda.metafacades.uml.AttributeFacade#isAddOnly() 1521 */ 1522 public boolean isAddOnly() 1523 { 1524 return this.getSuperManageableEntityAttribute().isAddOnly(); 1525 } 1526 1527 /** 1528 * True if this attribute can be modified. 1529 * @see org.andromda.metafacades.uml.AttributeFacade#isChangeable() 1530 */ 1531 public boolean isChangeable() 1532 { 1533 return this.getSuperManageableEntityAttribute().isChangeable(); 1534 } 1535 1536 /** 1537 * Indicates if the default value is present. 1538 * @see org.andromda.metafacades.uml.AttributeFacade#isDefaultValuePresent() 1539 */ 1540 public boolean isDefaultValuePresent() 1541 { 1542 return this.getSuperManageableEntityAttribute().isDefaultValuePresent(); 1543 } 1544 1545 /** 1546 * If the attribute is derived (its value is computed). UML2 only. UML14 always returns false. 1547 * Default=false. 1548 * @see org.andromda.metafacades.uml.AttributeFacade#isDerived() 1549 */ 1550 public boolean isDerived() 1551 { 1552 return this.getSuperManageableEntityAttribute().isDerived(); 1553 } 1554 1555 /** 1556 * True if this attribute is owned by an enumeration. 1557 * @see org.andromda.metafacades.uml.AttributeFacade#isEnumerationLiteral() 1558 */ 1559 public boolean isEnumerationLiteral() 1560 { 1561 return this.getSuperManageableEntityAttribute().isEnumerationLiteral(); 1562 } 1563 1564 /** 1565 * Returns true if enumeration literal parameters exist (defined by tagged value) for the 1566 * literal. 1567 * @see org.andromda.metafacades.uml.AttributeFacade#isEnumerationLiteralParametersExist() 1568 */ 1569 public boolean isEnumerationLiteralParametersExist() 1570 { 1571 return this.getSuperManageableEntityAttribute().isEnumerationLiteralParametersExist(); 1572 } 1573 1574 /** 1575 * True if this attribute is owned by an enumeration but is defined as a member variable (NOT a 1576 * literal). 1577 * @see org.andromda.metafacades.uml.AttributeFacade#isEnumerationMember() 1578 */ 1579 public boolean isEnumerationMember() 1580 { 1581 return this.getSuperManageableEntityAttribute().isEnumerationMember(); 1582 } 1583 1584 /** 1585 * IsLeaf property in the operation. If true, operation is final, cannot be extended or 1586 * implemented by a descendant. 1587 * @see org.andromda.metafacades.uml.AttributeFacade#isLeaf() 1588 */ 1589 public boolean isLeaf() 1590 { 1591 return this.getSuperManageableEntityAttribute().isLeaf(); 1592 } 1593 1594 /** 1595 * Whether or not this attribute has a multiplicity greater than 1. 1596 * @see org.andromda.metafacades.uml.AttributeFacade#isMany() 1597 */ 1598 public boolean isMany() 1599 { 1600 return this.getSuperManageableEntityAttribute().isMany(); 1601 } 1602 1603 /** 1604 * Indicates whether or not the attributes are ordered (if multiplicity is greater than 1). 1605 * @see org.andromda.metafacades.uml.AttributeFacade#isOrdered() 1606 */ 1607 public boolean isOrdered() 1608 { 1609 return this.getSuperManageableEntityAttribute().isOrdered(); 1610 } 1611 1612 /** 1613 * Whether or not this attribute can be modified. 1614 * @see org.andromda.metafacades.uml.AttributeFacade#isReadOnly() 1615 */ 1616 public boolean isReadOnly() 1617 { 1618 return this.getSuperManageableEntityAttribute().isReadOnly(); 1619 } 1620 1621 /** 1622 * Whether or not the multiplicity of this attribute is 1. 1623 * @see org.andromda.metafacades.uml.AttributeFacade#isRequired() 1624 */ 1625 public boolean isRequired() 1626 { 1627 return this.getSuperManageableEntityAttribute().isRequired(); 1628 } 1629 1630 /** 1631 * Indicates if this attribute is 'static', meaning it has a classifier scope. 1632 * @see org.andromda.metafacades.uml.AttributeFacade#isStatic() 1633 */ 1634 public boolean isStatic() 1635 { 1636 return this.getSuperManageableEntityAttribute().isStatic(); 1637 } 1638 1639 /** 1640 * If the attribute is unique within the Collection type. UML2 only. UML14 always returns false. 1641 * Unique+Ordered determines the implementation Collection type. Default=false. 1642 * @see org.andromda.metafacades.uml.AttributeFacade#isUnique() 1643 */ 1644 public boolean isUnique() 1645 { 1646 return this.getSuperManageableEntityAttribute().isUnique(); 1647 } 1648 1649 /** 1650 * The name of the index to create on a column that persists the entity attribute. 1651 * @see org.andromda.metafacades.uml.EntityAttribute#getColumnIndex() 1652 */ 1653 public String getColumnIndex() 1654 { 1655 return this.getSuperManageableEntityAttribute().getColumnIndex(); 1656 } 1657 1658 /** 1659 * The length of the column that persists this entity attribute. 1660 * @see org.andromda.metafacades.uml.EntityAttribute#getColumnLength() 1661 */ 1662 public String getColumnLength() 1663 { 1664 return this.getSuperManageableEntityAttribute().getColumnLength(); 1665 } 1666 1667 /** 1668 * The name of the table column to which this entity is mapped. 1669 * @see org.andromda.metafacades.uml.EntityAttribute#getColumnName() 1670 */ 1671 public String getColumnName() 1672 { 1673 return this.getSuperManageableEntityAttribute().getColumnName(); 1674 } 1675 1676 /** 1677 * The PIM to language specific mappings for JDBC. 1678 * @see org.andromda.metafacades.uml.EntityAttribute#getJdbcMappings() 1679 */ 1680 public TypeMappings getJdbcMappings() 1681 { 1682 return this.getSuperManageableEntityAttribute().getJdbcMappings(); 1683 } 1684 1685 /** 1686 * The JDBC type for this entity attribute. 1687 * @see org.andromda.metafacades.uml.EntityAttribute#getJdbcType() 1688 */ 1689 public String getJdbcType() 1690 { 1691 return this.getSuperManageableEntityAttribute().getJdbcType(); 1692 } 1693 1694 /** 1695 * The SQL mappings (i.e. the mappings which provide PIM to SQL mappings). 1696 * @see org.andromda.metafacades.uml.EntityAttribute#getSqlMappings() 1697 */ 1698 public TypeMappings getSqlMappings() 1699 { 1700 return this.getSuperManageableEntityAttribute().getSqlMappings(); 1701 } 1702 1703 /** 1704 * The SQL type for this attribute. 1705 * @see org.andromda.metafacades.uml.EntityAttribute#getSqlType() 1706 */ 1707 public String getSqlType() 1708 { 1709 return this.getSuperManageableEntityAttribute().getSqlType(); 1710 } 1711 1712 /** 1713 * The name of the unique-key that this unique attribute belongs 1714 * @see org.andromda.metafacades.uml.EntityAttribute#getUniqueGroup() 1715 */ 1716 public String getUniqueGroup() 1717 { 1718 return this.getSuperManageableEntityAttribute().getUniqueGroup(); 1719 } 1720 1721 /** 1722 * True if this attribute is an identifier for its entity. 1723 * @see org.andromda.metafacades.uml.EntityAttribute#isIdentifier() 1724 */ 1725 public boolean isIdentifier() 1726 { 1727 return this.getSuperManageableEntityAttribute().isIdentifier(); 1728 } 1729 1730 /** 1731 * Indicates this attribute should be ignored by the persistence layer. 1732 * @see org.andromda.metafacades.uml.EntityAttribute#isTransient() 1733 */ 1734 public boolean isTransient() 1735 { 1736 return this.getSuperManageableEntityAttribute().isTransient(); 1737 } 1738 1739 /** 1740 * Whether or not this attribute should be displayed. 1741 * @see ManageableEntityAttribute#isDisplay() 1742 */ 1743 public boolean isDisplay() 1744 { 1745 return this.getSuperManageableEntityAttribute().isDisplay(); 1746 } 1747 1748 /** 1749 * Whether or not this attribute can be read in a call isolated from the rest (for example when 1750 * downloading binary fields). 1751 * @see ManageableEntityAttribute#isManageableGetterAvailable() 1752 */ 1753 public boolean isManageableGetterAvailable() 1754 { 1755 return this.getSuperManageableEntityAttribute().isManageableGetterAvailable(); 1756 } 1757 1758 /** 1759 * Copies all tagged values from the given ModelElementFacade to this model element facade. 1760 * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element) 1761 */ 1762 public void copyTaggedValues(ModelElementFacade element) 1763 { 1764 this.getSuperManageableEntityAttribute().copyTaggedValues(element); 1765 } 1766 1767 /** 1768 * Finds the tagged value with the specified 'tagName'. In case there are more values the first 1769 * one found will be returned. 1770 * @see ModelElementFacade#findTaggedValue(String tagName) 1771 */ 1772 public Object findTaggedValue(String tagName) 1773 { 1774 return this.getSuperManageableEntityAttribute().findTaggedValue(tagName); 1775 } 1776 1777 /** 1778 * Returns all the values for the tagged value with the specified name. The returned collection 1779 * will contains only String instances, or will be empty. Never null. 1780 * @see ModelElementFacade#findTaggedValues(String tagName) 1781 */ 1782 public Collection<Object> findTaggedValues(String tagName) 1783 { 1784 return this.getSuperManageableEntityAttribute().findTaggedValues(tagName); 1785 } 1786 1787 /** 1788 * Returns the fully qualified name of the model element. The fully qualified name includes 1789 * complete package qualified name of the underlying model element. The templates parameter will 1790 * be replaced by the correct one given the binding relation of the parameter to this element. 1791 * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement) 1792 */ 1793 public String getBindedFullyQualifiedName(ModelElementFacade bindedElement) 1794 { 1795 return this.getSuperManageableEntityAttribute().getBindedFullyQualifiedName(bindedElement); 1796 } 1797 1798 /** 1799 * Gets all constraints belonging to the model element. 1800 * @see ModelElementFacade#getConstraints() 1801 */ 1802 public Collection<ConstraintFacade> getConstraints() 1803 { 1804 return this.getSuperManageableEntityAttribute().getConstraints(); 1805 } 1806 1807 /** 1808 * Returns the constraints of the argument kind that have been placed onto this model. Typical 1809 * kinds are "inv", "pre" and "post". Other kinds are possible. 1810 * @see ModelElementFacade#getConstraints(String kind) 1811 */ 1812 public Collection<ConstraintFacade> getConstraints(String kind) 1813 { 1814 return this.getSuperManageableEntityAttribute().getConstraints(kind); 1815 } 1816 1817 /** 1818 * Gets the documentation for the model element, The indent argument is prefixed to each line. 1819 * By default this method wraps lines after 64 characters. 1820 * This method is equivalent to <code>getDocumentation(indent, 64)</code>. 1821 * @see ModelElementFacade#getDocumentation(String indent) 1822 */ 1823 public String getDocumentation(String indent) 1824 { 1825 return this.getSuperManageableEntityAttribute().getDocumentation(indent); 1826 } 1827 1828 /** 1829 * This method returns the documentation for this model element, with the lines wrapped after 1830 * the specified number of characters, values of less than 1 will indicate no line wrapping is 1831 * required. By default paragraphs are returned as HTML. 1832 * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>. 1833 * @see ModelElementFacade#getDocumentation(String indent, int lineLength) 1834 */ 1835 public String getDocumentation(String indent, int lineLength) 1836 { 1837 return this.getSuperManageableEntityAttribute().getDocumentation(indent, lineLength); 1838 } 1839 1840 /** 1841 * This method returns the documentation for this model element, with the lines wrapped after 1842 * the specified number of characters, values of less than 1 will indicate no line wrapping is 1843 * required. HTML style determines if HTML Escaping is applied. 1844 * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle) 1845 */ 1846 public String getDocumentation(String indent, int lineLength, boolean htmlStyle) 1847 { 1848 return this.getSuperManageableEntityAttribute().getDocumentation(indent, lineLength, htmlStyle); 1849 } 1850 1851 /** 1852 * The fully qualified name of this model element. 1853 * @see ModelElementFacade#getFullyQualifiedName() 1854 */ 1855 public String getFullyQualifiedName() 1856 { 1857 return this.getSuperManageableEntityAttribute().getFullyQualifiedName(); 1858 } 1859 1860 /** 1861 * Returns the fully qualified name of the model element. The fully qualified name includes 1862 * complete package qualified name of the underlying model element. If modelName is true, then 1863 * the original name of the model element (the name contained within the model) will be the name 1864 * returned, otherwise a name from a language mapping will be returned. 1865 * @see ModelElementFacade#getFullyQualifiedName(boolean modelName) 1866 */ 1867 public String getFullyQualifiedName(boolean modelName) 1868 { 1869 return this.getSuperManageableEntityAttribute().getFullyQualifiedName(modelName); 1870 } 1871 1872 /** 1873 * Returns the fully qualified name as a path, the returned value always starts with out a slash 1874 * '/'. 1875 * @see ModelElementFacade#getFullyQualifiedNamePath() 1876 */ 1877 public String getFullyQualifiedNamePath() 1878 { 1879 return this.getSuperManageableEntityAttribute().getFullyQualifiedNamePath(); 1880 } 1881 1882 /** 1883 * Gets the unique identifier of the underlying model element. 1884 * @see ModelElementFacade#getId() 1885 */ 1886 public String getId() 1887 { 1888 return this.getSuperManageableEntityAttribute().getId(); 1889 } 1890 1891 /** 1892 * UML2: Retrieves the keywords for this element. Used to modify implementation properties which 1893 * are not represented by other properties, i.e. native, transient, volatile, synchronized, 1894 * (added annotations) override, deprecated. Can also be used to suppress compiler warnings: 1895 * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require 1896 * JDK5 compiler level. 1897 * @see ModelElementFacade#getKeywords() 1898 */ 1899 public Collection<String> getKeywords() 1900 { 1901 return this.getSuperManageableEntityAttribute().getKeywords(); 1902 } 1903 1904 /** 1905 * UML2: Retrieves a localized label for this named element. 1906 * @see ModelElementFacade#getLabel() 1907 */ 1908 public String getLabel() 1909 { 1910 return this.getSuperManageableEntityAttribute().getLabel(); 1911 } 1912 1913 /** 1914 * The language mappings that have been set for this model element. 1915 * @see ModelElementFacade#getLanguageMappings() 1916 */ 1917 public TypeMappings getLanguageMappings() 1918 { 1919 return this.getSuperManageableEntityAttribute().getLanguageMappings(); 1920 } 1921 1922 /** 1923 * Return the model containing this model element (multiple models may be loaded and processed 1924 * at the same time). 1925 * @see ModelElementFacade#getModel() 1926 */ 1927 public ModelFacade getModel() 1928 { 1929 return this.getSuperManageableEntityAttribute().getModel(); 1930 } 1931 1932 /** 1933 * The name of the model element. 1934 * @see ModelElementFacade#getName() 1935 */ 1936 public String getName() 1937 { 1938 return this.getSuperManageableEntityAttribute().getName(); 1939 } 1940 1941 /** 1942 * Gets the package to which this model element belongs. 1943 * @see ModelElementFacade#getPackage() 1944 */ 1945 public ModelElementFacade getPackage() 1946 { 1947 return this.getSuperManageableEntityAttribute().getPackage(); 1948 } 1949 1950 /** 1951 * The name of this model element's package. 1952 * @see ModelElementFacade#getPackageName() 1953 */ 1954 public String getPackageName() 1955 { 1956 return this.getSuperManageableEntityAttribute().getPackageName(); 1957 } 1958 1959 /** 1960 * Gets the package name (optionally providing the ability to retrieve the model name and not 1961 * the mapped name). 1962 * @see ModelElementFacade#getPackageName(boolean modelName) 1963 */ 1964 public String getPackageName(boolean modelName) 1965 { 1966 return this.getSuperManageableEntityAttribute().getPackageName(modelName); 1967 } 1968 1969 /** 1970 * Returns the package as a path, the returned value always starts with out a slash '/'. 1971 * @see ModelElementFacade#getPackagePath() 1972 */ 1973 public String getPackagePath() 1974 { 1975 return this.getSuperManageableEntityAttribute().getPackagePath(); 1976 } 1977 1978 /** 1979 * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the 1980 * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from 1981 * the names of the containing namespaces starting at the root of the hierarchy and ending with 1982 * the name of the NamedElement itself. 1983 * @see ModelElementFacade#getQualifiedName() 1984 */ 1985 public String getQualifiedName() 1986 { 1987 return this.getSuperManageableEntityAttribute().getQualifiedName(); 1988 } 1989 1990 /** 1991 * Gets the root package for the model element. 1992 * @see ModelElementFacade#getRootPackage() 1993 */ 1994 public PackageFacade getRootPackage() 1995 { 1996 return this.getSuperManageableEntityAttribute().getRootPackage(); 1997 } 1998 1999 /** 2000 * Gets the dependencies for which this model element is the source. 2001 * @see ModelElementFacade#getSourceDependencies() 2002 */ 2003 public Collection<DependencyFacade> getSourceDependencies() 2004 { 2005 return this.getSuperManageableEntityAttribute().getSourceDependencies(); 2006 } 2007 2008 /** 2009 * If this model element is the context of an activity graph, this represents that activity 2010 * graph. 2011 * @see ModelElementFacade#getStateMachineContext() 2012 */ 2013 public StateMachineFacade getStateMachineContext() 2014 { 2015 return this.getSuperManageableEntityAttribute().getStateMachineContext(); 2016 } 2017 2018 /** 2019 * The collection of ALL stereotype names for this model element. 2020 * @see ModelElementFacade#getStereotypeNames() 2021 */ 2022 public Collection<String> getStereotypeNames() 2023 { 2024 return this.getSuperManageableEntityAttribute().getStereotypeNames(); 2025 } 2026 2027 /** 2028 * Gets all stereotypes for this model element. 2029 * @see ModelElementFacade#getStereotypes() 2030 */ 2031 public Collection<StereotypeFacade> getStereotypes() 2032 { 2033 return this.getSuperManageableEntityAttribute().getStereotypes(); 2034 } 2035 2036 /** 2037 * Return the TaggedValues associated with this model element, under all stereotypes. 2038 * @see ModelElementFacade#getTaggedValues() 2039 */ 2040 public Collection<TaggedValueFacade> getTaggedValues() 2041 { 2042 return this.getSuperManageableEntityAttribute().getTaggedValues(); 2043 } 2044 2045 /** 2046 * Gets the dependencies for which this model element is the target. 2047 * @see ModelElementFacade#getTargetDependencies() 2048 */ 2049 public Collection<DependencyFacade> getTargetDependencies() 2050 { 2051 return this.getSuperManageableEntityAttribute().getTargetDependencies(); 2052 } 2053 2054 /** 2055 * Get the template parameter for this model element having the parameterName 2056 * @see ModelElementFacade#getTemplateParameter(String parameterName) 2057 */ 2058 public Object getTemplateParameter(String parameterName) 2059 { 2060 return this.getSuperManageableEntityAttribute().getTemplateParameter(parameterName); 2061 } 2062 2063 /** 2064 * Get the template parameters for this model element 2065 * @see ModelElementFacade#getTemplateParameters() 2066 */ 2067 public Collection<TemplateParameterFacade> getTemplateParameters() 2068 { 2069 return this.getSuperManageableEntityAttribute().getTemplateParameters(); 2070 } 2071 2072 /** 2073 * The visibility (i.e. public, private, protected or package) of the model element, will 2074 * attempt a lookup for these values in the language mappings (if any). 2075 * @see ModelElementFacade#getVisibility() 2076 */ 2077 public String getVisibility() 2078 { 2079 return this.getSuperManageableEntityAttribute().getVisibility(); 2080 } 2081 2082 /** 2083 * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance 2084 * is taken into account when searching for the stereotype), false otherwise. 2085 * @see ModelElementFacade#hasExactStereotype(String stereotypeName) 2086 */ 2087 public boolean hasExactStereotype(String stereotypeName) 2088 { 2089 return this.getSuperManageableEntityAttribute().hasExactStereotype(stereotypeName); 2090 } 2091 2092 /** 2093 * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma, 2094 * pipe, semicolon, or << >> 2095 * @see ModelElementFacade#hasKeyword(String keywordName) 2096 */ 2097 public boolean hasKeyword(String keywordName) 2098 { 2099 return this.getSuperManageableEntityAttribute().hasKeyword(keywordName); 2100 } 2101 2102 /** 2103 * Returns true if the model element has the specified stereotype. If the stereotype itself 2104 * does not match, then a search will be made up the stereotype inheritance hierarchy, and if 2105 * one of the stereotype's ancestors has a matching name this method will return true, false 2106 * otherwise. 2107 * For example, if we have a certain stereotype called <<exception>> and a model element has a 2108 * stereotype called <<applicationException>> which extends <<exception>>, when calling this 2109 * method with 'stereotypeName' defined as 'exception' the method would return true since 2110 * <<applicationException>> inherits from <<exception>>. If you want to check if the model 2111 * element has the exact stereotype, then use the method 'hasExactStereotype' instead. 2112 * @see ModelElementFacade#hasStereotype(String stereotypeName) 2113 */ 2114 public boolean hasStereotype(String stereotypeName) 2115 { 2116 return this.getSuperManageableEntityAttribute().hasStereotype(stereotypeName); 2117 } 2118 2119 /** 2120 * True if there are target dependencies from this element that are instances of BindingFacade. 2121 * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies. 2122 * @see ModelElementFacade#isBindingDependenciesPresent() 2123 */ 2124 public boolean isBindingDependenciesPresent() 2125 { 2126 return this.getSuperManageableEntityAttribute().isBindingDependenciesPresent(); 2127 } 2128 2129 /** 2130 * Indicates if any constraints are present on this model element. 2131 * @see ModelElementFacade#isConstraintsPresent() 2132 */ 2133 public boolean isConstraintsPresent() 2134 { 2135 return this.getSuperManageableEntityAttribute().isConstraintsPresent(); 2136 } 2137 2138 /** 2139 * Indicates if any documentation is present on this model element. 2140 * @see ModelElementFacade#isDocumentationPresent() 2141 */ 2142 public boolean isDocumentationPresent() 2143 { 2144 return this.getSuperManageableEntityAttribute().isDocumentationPresent(); 2145 } 2146 2147 /** 2148 * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript. 2149 * @see ModelElementFacade#isReservedWord() 2150 */ 2151 public boolean isReservedWord() 2152 { 2153 return this.getSuperManageableEntityAttribute().isReservedWord(); 2154 } 2155 2156 /** 2157 * True is there are template parameters on this model element. For UML2, applies to Class, 2158 * Operation, Property, and Parameter. 2159 * @see ModelElementFacade#isTemplateParametersPresent() 2160 */ 2161 public boolean isTemplateParametersPresent() 2162 { 2163 return this.getSuperManageableEntityAttribute().isTemplateParametersPresent(); 2164 } 2165 2166 /** 2167 * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++, 2168 * JavaScript. Contains no spaces, special characters etc. Constraint always applied on 2169 * Enumerations and Interfaces, optionally applies on other model elements. 2170 * @see ModelElementFacade#isValidIdentifierName() 2171 */ 2172 public boolean isValidIdentifierName() 2173 { 2174 return this.getSuperManageableEntityAttribute().isValidIdentifierName(); 2175 } 2176 2177 /** 2178 * Searches for the constraint with the specified 'name' on this model element, and if found 2179 * translates it using the specified 'translation' from a translation library discovered by the 2180 * framework. 2181 * @see ModelElementFacade#translateConstraint(String name, String translation) 2182 */ 2183 public String translateConstraint(String name, String translation) 2184 { 2185 return this.getSuperManageableEntityAttribute().translateConstraint(name, translation); 2186 } 2187 2188 /** 2189 * Translates all constraints belonging to this model element with the given 'translation'. 2190 * @see ModelElementFacade#translateConstraints(String translation) 2191 */ 2192 public String[] translateConstraints(String translation) 2193 { 2194 return this.getSuperManageableEntityAttribute().translateConstraints(translation); 2195 } 2196 2197 /** 2198 * Translates the constraints of the specified 'kind' belonging to this model element. 2199 * @see ModelElementFacade#translateConstraints(String kind, String translation) 2200 */ 2201 public String[] translateConstraints(String kind, String translation) 2202 { 2203 return this.getSuperManageableEntityAttribute().translateConstraints(kind, translation); 2204 } 2205 2206 /** 2207 * @see org.andromda.core.metafacade.MetafacadeBase#initialize() 2208 */ 2209 @Override 2210 public void initialize() 2211 { 2212 this.getSuperManageableEntityAttribute().initialize(); 2213 } 2214 2215 /** 2216 * @return Object getSuperManageableEntityAttribute().getValidationOwner() 2217 * @see org.andromda.core.metafacade.MetafacadeBase#getValidationOwner() 2218 */ 2219 @Override 2220 public Object getValidationOwner() 2221 { 2222 Object owner = this.getSuperManageableEntityAttribute().getValidationOwner(); 2223 return owner; 2224 } 2225 2226 /** 2227 * @return String getSuperManageableEntityAttribute().getValidationName() 2228 * @see org.andromda.core.metafacade.MetafacadeBase#getValidationName() 2229 */ 2230 @Override 2231 public String getValidationName() 2232 { 2233 String name = this.getSuperManageableEntityAttribute().getValidationName(); 2234 return name; 2235 } 2236 2237 /** 2238 * @param validationMessages Collection<ModelValidationMessage> 2239 * @see org.andromda.core.metafacade.MetafacadeBase#validateInvariants(Collection validationMessages) 2240 */ 2241 @Override 2242 public void validateInvariants(Collection<ModelValidationMessage> validationMessages) 2243 { 2244 this.getSuperManageableEntityAttribute().validateInvariants(validationMessages); 2245 } 2246 2247 /** 2248 * The property that stores the name of the metafacade. 2249 */ 2250 private static final String NAME_PROPERTY = "name"; 2251 private static final String FQNAME_PROPERTY = "fullyQualifiedName"; 2252 2253 /** 2254 * @see Object#toString() 2255 */ 2256 @Override 2257 public String toString() 2258 { 2259 final StringBuilder toString = new StringBuilder(this.getClass().getName()); 2260 toString.append("["); 2261 try 2262 { 2263 toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY)); 2264 } 2265 catch (final Throwable tryAgain) 2266 { 2267 try 2268 { 2269 toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY)); 2270 } 2271 catch (final Throwable ignore) 2272 { 2273 // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property 2274 } 2275 } 2276 toString.append("]"); 2277 return toString.toString(); 2278 } 2279}