001// license-header java merge-point 002// 003// Attention: generated code (by MetafacadeLogic.vsl) - do not modify! 004// 005package org.andromda.cartridges.jsf.metafacades; 006 007import java.util.Collection; 008import java.util.List; 009import java.util.Map; 010import org.andromda.core.common.Introspector; 011import org.andromda.core.metafacade.MetafacadeBase; 012import org.andromda.core.metafacade.MetafacadeFactory; 013import org.andromda.core.metafacade.ModelValidationMessage; 014import org.andromda.metafacades.uml.ActionFacade; 015import org.andromda.metafacades.uml.ConstraintFacade; 016import org.andromda.metafacades.uml.DependencyFacade; 017import org.andromda.metafacades.uml.EventFacade; 018import org.andromda.metafacades.uml.FrontEndAction; 019import org.andromda.metafacades.uml.FrontEndActionState; 020import org.andromda.metafacades.uml.FrontEndActivityGraph; 021import org.andromda.metafacades.uml.FrontEndController; 022import org.andromda.metafacades.uml.FrontEndControllerOperation; 023import org.andromda.metafacades.uml.FrontEndEvent; 024import org.andromda.metafacades.uml.FrontEndForward; 025import org.andromda.metafacades.uml.FrontEndParameter; 026import org.andromda.metafacades.uml.FrontEndUseCase; 027import org.andromda.metafacades.uml.FrontEndView; 028import org.andromda.metafacades.uml.GuardFacade; 029import org.andromda.metafacades.uml.ModelElementFacade; 030import org.andromda.metafacades.uml.ModelFacade; 031import org.andromda.metafacades.uml.PackageFacade; 032import org.andromda.metafacades.uml.ParameterFacade; 033import org.andromda.metafacades.uml.StateMachineFacade; 034import org.andromda.metafacades.uml.StateVertexFacade; 035import org.andromda.metafacades.uml.StereotypeFacade; 036import org.andromda.metafacades.uml.TaggedValueFacade; 037import org.andromda.metafacades.uml.TemplateParameterFacade; 038import org.andromda.metafacades.uml.TypeMappings; 039import org.apache.log4j.Logger; 040 041/** 042 * Represents an action taken during a "front-end" event execution on a JSF application. 043 * MetafacadeLogic for JSFAction 044 * 045 * @see JSFAction 046 */ 047public abstract class JSFActionLogic 048 extends MetafacadeBase 049 implements JSFAction 050{ 051 /** 052 * The underlying UML object 053 * @see Object 054 */ 055 protected Object metaObject; 056 057 /** Create Metafacade implementation instance using the MetafacadeFactory from the context 058 * @param metaObjectIn 059 * @param context 060 */ 061 protected JSFActionLogic(Object metaObjectIn, String context) 062 { 063 super(metaObjectIn, getContext(context)); 064 this.superFrontEndAction = 065 (FrontEndAction) 066 MetafacadeFactory.getInstance().createFacadeImpl( 067 "org.andromda.metafacades.uml.FrontEndAction", 068 metaObjectIn, 069 getContext(context)); 070 this.metaObject = metaObjectIn; 071 } 072 073 /** 074 * The logger instance. 075 */ 076 private static final Logger logger = Logger.getLogger(JSFActionLogic.class); 077 078 /** 079 * Gets the context for this metafacade logic instance. 080 * @param context String. Set to JSFAction if null 081 * @return context String 082 */ 083 private static String getContext(String context) 084 { 085 if (context == null) 086 { 087 context = "org.andromda.cartridges.jsf.metafacades.JSFAction"; 088 } 089 return context; 090 } 091 092 private FrontEndAction superFrontEndAction; 093 private boolean superFrontEndActionInitialized = false; 094 095 /** 096 * Gets the FrontEndAction parent instance. 097 * @return this.superFrontEndAction FrontEndAction 098 */ 099 private FrontEndAction getSuperFrontEndAction() 100 { 101 if (!this.superFrontEndActionInitialized) 102 { 103 ((MetafacadeBase)this.superFrontEndAction).setMetafacadeContext(this.getMetafacadeContext()); 104 this.superFrontEndActionInitialized = true; 105 } 106 return this.superFrontEndAction; 107 } 108 109 /** Reset context only for non-root metafacades 110 * @param context 111 * @see MetafacadeBase#resetMetafacadeContext(String context) 112 */ 113 @Override 114 public void resetMetafacadeContext(String context) 115 { 116 if (!this.contextRoot) // reset context only for non-root metafacades 117 { 118 context = getContext(context); // to have same value as in original constructor call 119 setMetafacadeContext (context); 120 if (this.superFrontEndActionInitialized) 121 { 122 ((MetafacadeBase)this.superFrontEndAction).resetMetafacadeContext(context); 123 } 124 } 125 } 126 127 /** 128 * @return boolean true always 129 * @see JSFAction 130 */ 131 public boolean isJSFActionMetaType() 132 { 133 return true; 134 } 135 136 // --------------- attributes --------------------- 137 138 /** 139 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getFormImplementationName() 140 * @return String 141 */ 142 protected abstract String handleGetFormImplementationName(); 143 144 private String __formImplementationName1a; 145 private boolean __formImplementationName1aSet = false; 146 147 /** 148 * The name of the form implementation. 149 * @return (String)handleGetFormImplementationName() 150 */ 151 public final String getFormImplementationName() 152 { 153 String formImplementationName1a = this.__formImplementationName1a; 154 if (!this.__formImplementationName1aSet) 155 { 156 // formImplementationName has no pre constraints 157 formImplementationName1a = handleGetFormImplementationName(); 158 // formImplementationName has no post constraints 159 this.__formImplementationName1a = formImplementationName1a; 160 if (isMetafacadePropertyCachingEnabled()) 161 { 162 this.__formImplementationName1aSet = true; 163 } 164 } 165 return formImplementationName1a; 166 } 167 168 /** 169 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getFormBeanName() 170 * @return String 171 */ 172 protected abstract String handleGetFormBeanName(); 173 174 private String __formBeanName2a; 175 private boolean __formBeanName2aSet = false; 176 177 /** 178 * The name of the bean under which the form is stored. 179 * @return (String)handleGetFormBeanName() 180 */ 181 public final String getFormBeanName() 182 { 183 String formBeanName2a = this.__formBeanName2a; 184 if (!this.__formBeanName2aSet) 185 { 186 // formBeanName has no pre constraints 187 formBeanName2a = handleGetFormBeanName(); 188 // formBeanName has no post constraints 189 this.__formBeanName2a = formBeanName2a; 190 if (isMetafacadePropertyCachingEnabled()) 191 { 192 this.__formBeanName2aSet = true; 193 } 194 } 195 return formBeanName2a; 196 } 197 198 /** 199 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getFullyQualifiedFormImplementationName() 200 * @return String 201 */ 202 protected abstract String handleGetFullyQualifiedFormImplementationName(); 203 204 private String __fullyQualifiedFormImplementationName3a; 205 private boolean __fullyQualifiedFormImplementationName3aSet = false; 206 207 /** 208 * The fully qualified name of the form implementation. 209 * @return (String)handleGetFullyQualifiedFormImplementationName() 210 */ 211 public final String getFullyQualifiedFormImplementationName() 212 { 213 String fullyQualifiedFormImplementationName3a = this.__fullyQualifiedFormImplementationName3a; 214 if (!this.__fullyQualifiedFormImplementationName3aSet) 215 { 216 // fullyQualifiedFormImplementationName has no pre constraints 217 fullyQualifiedFormImplementationName3a = handleGetFullyQualifiedFormImplementationName(); 218 // fullyQualifiedFormImplementationName has no post constraints 219 this.__fullyQualifiedFormImplementationName3a = fullyQualifiedFormImplementationName3a; 220 if (isMetafacadePropertyCachingEnabled()) 221 { 222 this.__fullyQualifiedFormImplementationName3aSet = true; 223 } 224 } 225 return fullyQualifiedFormImplementationName3a; 226 } 227 228 /** 229 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getFullyQualifiedFormImplementationPath() 230 * @return String 231 */ 232 protected abstract String handleGetFullyQualifiedFormImplementationPath(); 233 234 private String __fullyQualifiedFormImplementationPath4a; 235 private boolean __fullyQualifiedFormImplementationPath4aSet = false; 236 237 /** 238 * The fully qualified path of the form implementation. 239 * @return (String)handleGetFullyQualifiedFormImplementationPath() 240 */ 241 public final String getFullyQualifiedFormImplementationPath() 242 { 243 String fullyQualifiedFormImplementationPath4a = this.__fullyQualifiedFormImplementationPath4a; 244 if (!this.__fullyQualifiedFormImplementationPath4aSet) 245 { 246 // fullyQualifiedFormImplementationPath has no pre constraints 247 fullyQualifiedFormImplementationPath4a = handleGetFullyQualifiedFormImplementationPath(); 248 // fullyQualifiedFormImplementationPath has no post constraints 249 this.__fullyQualifiedFormImplementationPath4a = fullyQualifiedFormImplementationPath4a; 250 if (isMetafacadePropertyCachingEnabled()) 251 { 252 this.__fullyQualifiedFormImplementationPath4aSet = true; 253 } 254 } 255 return fullyQualifiedFormImplementationPath4a; 256 } 257 258 /** 259 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getFormScope() 260 * @return String 261 */ 262 protected abstract String handleGetFormScope(); 263 264 private String __formScope5a; 265 private boolean __formScope5aSet = false; 266 267 /** 268 * The scope of the JSF form (request, session,application,etc). 269 * @return (String)handleGetFormScope() 270 */ 271 public final String getFormScope() 272 { 273 String formScope5a = this.__formScope5a; 274 if (!this.__formScope5aSet) 275 { 276 // formScope has no pre constraints 277 formScope5a = handleGetFormScope(); 278 // formScope has no post constraints 279 this.__formScope5a = formScope5a; 280 if (isMetafacadePropertyCachingEnabled()) 281 { 282 this.__formScope5aSet = true; 283 } 284 } 285 return formScope5a; 286 } 287 288 /** 289 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getFormImplementationInterfaceList() 290 * @return String 291 */ 292 protected abstract String handleGetFormImplementationInterfaceList(); 293 294 private String __formImplementationInterfaceList6a; 295 private boolean __formImplementationInterfaceList6aSet = false; 296 297 /** 298 * A comma separated list of all the form interfaces which the form implementation implements. 299 * @return (String)handleGetFormImplementationInterfaceList() 300 */ 301 public final String getFormImplementationInterfaceList() 302 { 303 String formImplementationInterfaceList6a = this.__formImplementationInterfaceList6a; 304 if (!this.__formImplementationInterfaceList6aSet) 305 { 306 // formImplementationInterfaceList has no pre constraints 307 formImplementationInterfaceList6a = handleGetFormImplementationInterfaceList(); 308 // formImplementationInterfaceList has no post constraints 309 this.__formImplementationInterfaceList6a = formImplementationInterfaceList6a; 310 if (isMetafacadePropertyCachingEnabled()) 311 { 312 this.__formImplementationInterfaceList6aSet = true; 313 } 314 } 315 return formImplementationInterfaceList6a; 316 } 317 318 /** 319 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getPath() 320 * @return String 321 */ 322 protected abstract String handleGetPath(); 323 324 private String __path7a; 325 private boolean __path7aSet = false; 326 327 /** 328 * The path to this action. 329 * @return (String)handleGetPath() 330 */ 331 public final String getPath() 332 { 333 String path7a = this.__path7a; 334 if (!this.__path7aSet) 335 { 336 // path has no pre constraints 337 path7a = handleGetPath(); 338 // path has no post constraints 339 this.__path7a = path7a; 340 if (isMetafacadePropertyCachingEnabled()) 341 { 342 this.__path7aSet = true; 343 } 344 } 345 return path7a; 346 } 347 348 /** 349 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getPathRoot() 350 * @return String 351 */ 352 protected abstract String handleGetPathRoot(); 353 354 private String __pathRoot8a; 355 private boolean __pathRoot8aSet = false; 356 357 /** 358 * The path's root. 359 * @return (String)handleGetPathRoot() 360 */ 361 public final String getPathRoot() 362 { 363 String pathRoot8a = this.__pathRoot8a; 364 if (!this.__pathRoot8aSet) 365 { 366 // pathRoot has no pre constraints 367 pathRoot8a = handleGetPathRoot(); 368 // pathRoot has no post constraints 369 this.__pathRoot8a = pathRoot8a; 370 if (isMetafacadePropertyCachingEnabled()) 371 { 372 this.__pathRoot8aSet = true; 373 } 374 } 375 return pathRoot8a; 376 } 377 378 /** 379 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getMessageKey() 380 * @return String 381 */ 382 protected abstract String handleGetMessageKey(); 383 384 private String __messageKey9a; 385 private boolean __messageKey9aSet = false; 386 387 /** 388 * The default resource message key for this action. 389 * @return (String)handleGetMessageKey() 390 */ 391 public final String getMessageKey() 392 { 393 String messageKey9a = this.__messageKey9a; 394 if (!this.__messageKey9aSet) 395 { 396 // messageKey has no pre constraints 397 messageKey9a = handleGetMessageKey(); 398 // messageKey has no post constraints 399 this.__messageKey9a = messageKey9a; 400 if (isMetafacadePropertyCachingEnabled()) 401 { 402 this.__messageKey9aSet = true; 403 } 404 } 405 return messageKey9a; 406 } 407 408 /** 409 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getDocumentationKey() 410 * @return String 411 */ 412 protected abstract String handleGetDocumentationKey(); 413 414 private String __documentationKey10a; 415 private boolean __documentationKey10aSet = false; 416 417 /** 418 * A resource message key suited for the action''s documentation. 419 * @return (String)handleGetDocumentationKey() 420 */ 421 public final String getDocumentationKey() 422 { 423 String documentationKey10a = this.__documentationKey10a; 424 if (!this.__documentationKey10aSet) 425 { 426 // documentationKey has no pre constraints 427 documentationKey10a = handleGetDocumentationKey(); 428 // documentationKey has no post constraints 429 this.__documentationKey10a = documentationKey10a; 430 if (isMetafacadePropertyCachingEnabled()) 431 { 432 this.__documentationKey10aSet = true; 433 } 434 } 435 return documentationKey10a; 436 } 437 438 /** 439 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getDocumentationValue() 440 * @return String 441 */ 442 protected abstract String handleGetDocumentationValue(); 443 444 private String __documentationValue11a; 445 private boolean __documentationValue11aSet = false; 446 447 /** 448 * The resource messsage value suited for the action''s documentation. 449 * @return (String)handleGetDocumentationValue() 450 */ 451 public final String getDocumentationValue() 452 { 453 String documentationValue11a = this.__documentationValue11a; 454 if (!this.__documentationValue11aSet) 455 { 456 // documentationValue has no pre constraints 457 documentationValue11a = handleGetDocumentationValue(); 458 // documentationValue has no post constraints 459 this.__documentationValue11a = documentationValue11a; 460 if (isMetafacadePropertyCachingEnabled()) 461 { 462 this.__documentationValue11aSet = true; 463 } 464 } 465 return documentationValue11a; 466 } 467 468 /** 469 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getTriggerName() 470 * @return String 471 */ 472 protected abstract String handleGetTriggerName(); 473 474 private String __triggerName12a; 475 private boolean __triggerName12aSet = false; 476 477 /** 478 * The name of the trigger that triggers that action. 479 * @return (String)handleGetTriggerName() 480 */ 481 public final String getTriggerName() 482 { 483 String triggerName12a = this.__triggerName12a; 484 if (!this.__triggerName12aSet) 485 { 486 // triggerName has no pre constraints 487 triggerName12a = handleGetTriggerName(); 488 // triggerName has no post constraints 489 this.__triggerName12a = triggerName12a; 490 if (isMetafacadePropertyCachingEnabled()) 491 { 492 this.__triggerName12aSet = true; 493 } 494 } 495 return triggerName12a; 496 } 497 498 /** 499 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getViewFragmentPath() 500 * @return String 501 */ 502 protected abstract String handleGetViewFragmentPath(); 503 504 private String __viewFragmentPath13a; 505 private boolean __viewFragmentPath13aSet = false; 506 507 /** 508 * The path to the view fragment corresponding to this action 509 * @return (String)handleGetViewFragmentPath() 510 */ 511 public final String getViewFragmentPath() 512 { 513 String viewFragmentPath13a = this.__viewFragmentPath13a; 514 if (!this.__viewFragmentPath13aSet) 515 { 516 // viewFragmentPath has no pre constraints 517 viewFragmentPath13a = handleGetViewFragmentPath(); 518 // viewFragmentPath has no post constraints 519 this.__viewFragmentPath13a = viewFragmentPath13a; 520 if (isMetafacadePropertyCachingEnabled()) 521 { 522 this.__viewFragmentPath13aSet = true; 523 } 524 } 525 return viewFragmentPath13a; 526 } 527 528 /** 529 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getTableLinkName() 530 * @return String 531 */ 532 protected abstract String handleGetTableLinkName(); 533 534 private String __tableLinkName14a; 535 private boolean __tableLinkName14aSet = false; 536 537 /** 538 * The name of the table link specified for this action. 539 * @return (String)handleGetTableLinkName() 540 */ 541 public final String getTableLinkName() 542 { 543 String tableLinkName14a = this.__tableLinkName14a; 544 if (!this.__tableLinkName14aSet) 545 { 546 // tableLinkName has no pre constraints 547 tableLinkName14a = handleGetTableLinkName(); 548 // tableLinkName has no post constraints 549 this.__tableLinkName14a = tableLinkName14a; 550 if (isMetafacadePropertyCachingEnabled()) 551 { 552 this.__tableLinkName14aSet = true; 553 } 554 } 555 return tableLinkName14a; 556 } 557 558 /** 559 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getTableLinkColumnName() 560 * @return String 561 */ 562 protected abstract String handleGetTableLinkColumnName(); 563 564 private String __tableLinkColumnName15a; 565 private boolean __tableLinkColumnName15aSet = false; 566 567 /** 568 * The name of the column targetted by this action. 569 * @return (String)handleGetTableLinkColumnName() 570 */ 571 public final String getTableLinkColumnName() 572 { 573 String tableLinkColumnName15a = this.__tableLinkColumnName15a; 574 if (!this.__tableLinkColumnName15aSet) 575 { 576 // tableLinkColumnName has no pre constraints 577 tableLinkColumnName15a = handleGetTableLinkColumnName(); 578 // tableLinkColumnName has no post constraints 579 this.__tableLinkColumnName15a = tableLinkColumnName15a; 580 if (isMetafacadePropertyCachingEnabled()) 581 { 582 this.__tableLinkColumnName15aSet = true; 583 } 584 } 585 return tableLinkColumnName15a; 586 } 587 588 /** 589 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#isTableLink() 590 * @return boolean 591 */ 592 protected abstract boolean handleIsTableLink(); 593 594 private boolean __tableLink16a; 595 private boolean __tableLink16aSet = false; 596 597 /** 598 * Indicates if a table link name has been specified and it properly targets a table 599 * page-variable from the input page. 600 * @return (boolean)handleIsTableLink() 601 */ 602 public final boolean isTableLink() 603 { 604 boolean tableLink16a = this.__tableLink16a; 605 if (!this.__tableLink16aSet) 606 { 607 // tableLink has no pre constraints 608 tableLink16a = handleIsTableLink(); 609 // tableLink has no post constraints 610 this.__tableLink16a = tableLink16a; 611 if (isMetafacadePropertyCachingEnabled()) 612 { 613 this.__tableLink16aSet = true; 614 } 615 } 616 return tableLink16a; 617 } 618 619 /** 620 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#isHyperlink() 621 * @return boolean 622 */ 623 protected abstract boolean handleIsHyperlink(); 624 625 private boolean __hyperlink17a; 626 private boolean __hyperlink17aSet = false; 627 628 /** 629 * Indicates whether or not this action is represented by clicking on a hyperlink. 630 * @return (boolean)handleIsHyperlink() 631 */ 632 public final boolean isHyperlink() 633 { 634 boolean hyperlink17a = this.__hyperlink17a; 635 if (!this.__hyperlink17aSet) 636 { 637 // hyperlink has no pre constraints 638 hyperlink17a = handleIsHyperlink(); 639 // hyperlink has no post constraints 640 this.__hyperlink17a = hyperlink17a; 641 if (isMetafacadePropertyCachingEnabled()) 642 { 643 this.__hyperlink17aSet = true; 644 } 645 } 646 return hyperlink17a; 647 } 648 649 /** 650 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getActionClassName() 651 * @return String 652 */ 653 protected abstract String handleGetActionClassName(); 654 655 private String __actionClassName18a; 656 private boolean __actionClassName18aSet = false; 657 658 /** 659 * The name of the action class that executes this action. 660 * @return (String)handleGetActionClassName() 661 */ 662 public final String getActionClassName() 663 { 664 String actionClassName18a = this.__actionClassName18a; 665 if (!this.__actionClassName18aSet) 666 { 667 // actionClassName has no pre constraints 668 actionClassName18a = handleGetActionClassName(); 669 // actionClassName has no post constraints 670 this.__actionClassName18a = actionClassName18a; 671 if (isMetafacadePropertyCachingEnabled()) 672 { 673 this.__actionClassName18aSet = true; 674 } 675 } 676 return actionClassName18a; 677 } 678 679 /** 680 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getFullyQualifiedActionClassPath() 681 * @return String 682 */ 683 protected abstract String handleGetFullyQualifiedActionClassPath(); 684 685 private String __fullyQualifiedActionClassPath19a; 686 private boolean __fullyQualifiedActionClassPath19aSet = false; 687 688 /** 689 * The fully qualified path to the action class that execute this action. 690 * @return (String)handleGetFullyQualifiedActionClassPath() 691 */ 692 public final String getFullyQualifiedActionClassPath() 693 { 694 String fullyQualifiedActionClassPath19a = this.__fullyQualifiedActionClassPath19a; 695 if (!this.__fullyQualifiedActionClassPath19aSet) 696 { 697 // fullyQualifiedActionClassPath has no pre constraints 698 fullyQualifiedActionClassPath19a = handleGetFullyQualifiedActionClassPath(); 699 // fullyQualifiedActionClassPath has no post constraints 700 this.__fullyQualifiedActionClassPath19a = fullyQualifiedActionClassPath19a; 701 if (isMetafacadePropertyCachingEnabled()) 702 { 703 this.__fullyQualifiedActionClassPath19aSet = true; 704 } 705 } 706 return fullyQualifiedActionClassPath19a; 707 } 708 709 /** 710 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getControllerAction() 711 * @return String 712 */ 713 protected abstract String handleGetControllerAction(); 714 715 private String __controllerAction20a; 716 private boolean __controllerAction20aSet = false; 717 718 /** 719 * The name of the action on the controller that executions this action. 720 * @return (String)handleGetControllerAction() 721 */ 722 public final String getControllerAction() 723 { 724 String controllerAction20a = this.__controllerAction20a; 725 if (!this.__controllerAction20aSet) 726 { 727 // controllerAction has no pre constraints 728 controllerAction20a = handleGetControllerAction(); 729 // controllerAction has no post constraints 730 this.__controllerAction20a = controllerAction20a; 731 if (isMetafacadePropertyCachingEnabled()) 732 { 733 this.__controllerAction20aSet = true; 734 } 735 } 736 return controllerAction20a; 737 } 738 739 /** 740 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getFullyQualifiedActionClassName() 741 * @return String 742 */ 743 protected abstract String handleGetFullyQualifiedActionClassName(); 744 745 private String __fullyQualifiedActionClassName21a; 746 private boolean __fullyQualifiedActionClassName21aSet = false; 747 748 /** 749 * The fully qualified name of the action class that execute this action. 750 * @return (String)handleGetFullyQualifiedActionClassName() 751 */ 752 public final String getFullyQualifiedActionClassName() 753 { 754 String fullyQualifiedActionClassName21a = this.__fullyQualifiedActionClassName21a; 755 if (!this.__fullyQualifiedActionClassName21aSet) 756 { 757 // fullyQualifiedActionClassName has no pre constraints 758 fullyQualifiedActionClassName21a = handleGetFullyQualifiedActionClassName(); 759 // fullyQualifiedActionClassName has no post constraints 760 this.__fullyQualifiedActionClassName21a = fullyQualifiedActionClassName21a; 761 if (isMetafacadePropertyCachingEnabled()) 762 { 763 this.__fullyQualifiedActionClassName21aSet = true; 764 } 765 } 766 return fullyQualifiedActionClassName21a; 767 } 768 769 /** 770 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#isResettable() 771 * @return boolean 772 */ 773 protected abstract boolean handleIsResettable(); 774 775 private boolean __resettable22a; 776 private boolean __resettable22aSet = false; 777 778 /** 779 * Indicates whether or not the values passed along with this action can be reset or not. 780 * @return (boolean)handleIsResettable() 781 */ 782 public final boolean isResettable() 783 { 784 boolean resettable22a = this.__resettable22a; 785 if (!this.__resettable22aSet) 786 { 787 // resettable has no pre constraints 788 resettable22a = handleIsResettable(); 789 // resettable has no post constraints 790 this.__resettable22a = resettable22a; 791 if (isMetafacadePropertyCachingEnabled()) 792 { 793 this.__resettable22aSet = true; 794 } 795 } 796 return resettable22a; 797 } 798 799 /** 800 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getFormKey() 801 * @return String 802 */ 803 protected abstract String handleGetFormKey(); 804 805 private String __formKey23a; 806 private boolean __formKey23aSet = false; 807 808 /** 809 * The key that stores the form in which information is passed from one action to another. 810 * @return (String)handleGetFormKey() 811 */ 812 public final String getFormKey() 813 { 814 String formKey23a = this.__formKey23a; 815 if (!this.__formKey23aSet) 816 { 817 // formKey has no pre constraints 818 formKey23a = handleGetFormKey(); 819 // formKey has no post constraints 820 this.__formKey23a = formKey23a; 821 if (isMetafacadePropertyCachingEnabled()) 822 { 823 this.__formKey23aSet = true; 824 } 825 } 826 return formKey23a; 827 } 828 829 /** 830 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#isTableAction() 831 * @return boolean 832 */ 833 protected abstract boolean handleIsTableAction(); 834 835 private boolean __tableAction24a; 836 private boolean __tableAction24aSet = false; 837 838 /** 839 * Indicates that this action works on all rows of the table from the table link relation. 840 * @return (boolean)handleIsTableAction() 841 */ 842 public final boolean isTableAction() 843 { 844 boolean tableAction24a = this.__tableAction24a; 845 if (!this.__tableAction24aSet) 846 { 847 // tableAction has no pre constraints 848 tableAction24a = handleIsTableAction(); 849 // tableAction has no post constraints 850 this.__tableAction24a = tableAction24a; 851 if (isMetafacadePropertyCachingEnabled()) 852 { 853 this.__tableAction24aSet = true; 854 } 855 } 856 return tableAction24a; 857 } 858 859 /** 860 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#isValidationRequired() 861 * @return boolean 862 */ 863 protected abstract boolean handleIsValidationRequired(); 864 865 private boolean __validationRequired25a; 866 private boolean __validationRequired25aSet = false; 867 868 /** 869 * Indicates whether or not at least one parameter on this action requires validation. 870 * @return (boolean)handleIsValidationRequired() 871 */ 872 public final boolean isValidationRequired() 873 { 874 boolean validationRequired25a = this.__validationRequired25a; 875 if (!this.__validationRequired25aSet) 876 { 877 // validationRequired has no pre constraints 878 validationRequired25a = handleIsValidationRequired(); 879 // validationRequired has no post constraints 880 this.__validationRequired25a = validationRequired25a; 881 if (isMetafacadePropertyCachingEnabled()) 882 { 883 this.__validationRequired25aSet = true; 884 } 885 } 886 return validationRequired25a; 887 } 888 889 /** 890 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#isPopup() 891 * @return boolean 892 */ 893 protected abstract boolean handleIsPopup(); 894 895 private boolean __popup26a; 896 private boolean __popup26aSet = false; 897 898 /** 899 * Indicates if this action forwards to a popup (this is determed when the targetted view is a 900 * popup). 901 * @return (boolean)handleIsPopup() 902 */ 903 public final boolean isPopup() 904 { 905 boolean popup26a = this.__popup26a; 906 if (!this.__popup26aSet) 907 { 908 // popup has no pre constraints 909 popup26a = handleIsPopup(); 910 // popup has no post constraints 911 this.__popup26a = popup26a; 912 if (isMetafacadePropertyCachingEnabled()) 913 { 914 this.__popup26aSet = true; 915 } 916 } 917 return popup26a; 918 } 919 920 /** 921 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#isFormResetRequired() 922 * @return boolean 923 */ 924 protected abstract boolean handleIsFormResetRequired(); 925 926 private boolean __formResetRequired27a; 927 private boolean __formResetRequired27aSet = false; 928 929 /** 930 * Indicates if at least one parameter on the form requires being reset. 931 * @return (boolean)handleIsFormResetRequired() 932 */ 933 public final boolean isFormResetRequired() 934 { 935 boolean formResetRequired27a = this.__formResetRequired27a; 936 if (!this.__formResetRequired27aSet) 937 { 938 // formResetRequired has no pre constraints 939 formResetRequired27a = handleIsFormResetRequired(); 940 // formResetRequired has no post constraints 941 this.__formResetRequired27a = formResetRequired27a; 942 if (isMetafacadePropertyCachingEnabled()) 943 { 944 this.__formResetRequired27aSet = true; 945 } 946 } 947 return formResetRequired27a; 948 } 949 950 /** 951 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#isFormReset() 952 * @return boolean 953 */ 954 protected abstract boolean handleIsFormReset(); 955 956 private boolean __formReset28a; 957 private boolean __formReset28aSet = false; 958 959 /** 960 * Whether or not the entire form should be reset (all action parameters on the form). 961 * @return (boolean)handleIsFormReset() 962 */ 963 public final boolean isFormReset() 964 { 965 boolean formReset28a = this.__formReset28a; 966 if (!this.__formReset28aSet) 967 { 968 // formReset has no pre constraints 969 formReset28a = handleIsFormReset(); 970 // formReset has no post constraints 971 this.__formReset28a = formReset28a; 972 if (isMetafacadePropertyCachingEnabled()) 973 { 974 this.__formReset28aSet = true; 975 } 976 } 977 return formReset28a; 978 } 979 980 /** 981 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getFormImplementationGetter() 982 * @return String 983 */ 984 protected abstract String handleGetFormImplementationGetter(); 985 986 private String __formImplementationGetter29a; 987 private boolean __formImplementationGetter29aSet = false; 988 989 /** 990 * The signature of the accessor method that returns the form implementation instance. 991 * @return (String)handleGetFormImplementationGetter() 992 */ 993 public final String getFormImplementationGetter() 994 { 995 String formImplementationGetter29a = this.__formImplementationGetter29a; 996 if (!this.__formImplementationGetter29aSet) 997 { 998 // formImplementationGetter has no pre constraints 999 formImplementationGetter29a = handleGetFormImplementationGetter(); 1000 // formImplementationGetter has no post constraints 1001 this.__formImplementationGetter29a = formImplementationGetter29a; 1002 if (isMetafacadePropertyCachingEnabled()) 1003 { 1004 this.__formImplementationGetter29aSet = true; 1005 } 1006 } 1007 return formImplementationGetter29a; 1008 } 1009 1010 /** 1011 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getFormSerialVersionUID() 1012 * @return String 1013 */ 1014 protected abstract String handleGetFormSerialVersionUID(); 1015 1016 private String __formSerialVersionUID30a; 1017 private boolean __formSerialVersionUID30aSet = false; 1018 1019 /** 1020 * The calcuated serial version UID for this action's form. 1021 * @return (String)handleGetFormSerialVersionUID() 1022 */ 1023 public final String getFormSerialVersionUID() 1024 { 1025 String formSerialVersionUID30a = this.__formSerialVersionUID30a; 1026 if (!this.__formSerialVersionUID30aSet) 1027 { 1028 // formSerialVersionUID has no pre constraints 1029 formSerialVersionUID30a = handleGetFormSerialVersionUID(); 1030 // formSerialVersionUID has no post constraints 1031 this.__formSerialVersionUID30a = formSerialVersionUID30a; 1032 if (isMetafacadePropertyCachingEnabled()) 1033 { 1034 this.__formSerialVersionUID30aSet = true; 1035 } 1036 } 1037 return formSerialVersionUID30a; 1038 } 1039 1040 /** 1041 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#isFinalStateTarget() 1042 * @return boolean 1043 */ 1044 protected abstract boolean handleIsFinalStateTarget(); 1045 1046 private boolean __finalStateTarget31a; 1047 private boolean __finalStateTarget31aSet = false; 1048 1049 /** 1050 * Indicates whether or not a final state is the target of this action. 1051 * @return (boolean)handleIsFinalStateTarget() 1052 */ 1053 public final boolean isFinalStateTarget() 1054 { 1055 boolean finalStateTarget31a = this.__finalStateTarget31a; 1056 if (!this.__finalStateTarget31aSet) 1057 { 1058 // finalStateTarget has no pre constraints 1059 finalStateTarget31a = handleIsFinalStateTarget(); 1060 // finalStateTarget has no post constraints 1061 this.__finalStateTarget31a = finalStateTarget31a; 1062 if (isMetafacadePropertyCachingEnabled()) 1063 { 1064 this.__finalStateTarget31aSet = true; 1065 } 1066 } 1067 return finalStateTarget31a; 1068 } 1069 1070 /** 1071 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getFromOutcome() 1072 * @return String 1073 */ 1074 protected abstract String handleGetFromOutcome(); 1075 1076 private String __fromOutcome32a; 1077 private boolean __fromOutcome32aSet = false; 1078 1079 /** 1080 * The name that corresponds to the from-outcome in an navigational rule. 1081 * @return (String)handleGetFromOutcome() 1082 */ 1083 public final String getFromOutcome() 1084 { 1085 String fromOutcome32a = this.__fromOutcome32a; 1086 if (!this.__fromOutcome32aSet) 1087 { 1088 // fromOutcome has no pre constraints 1089 fromOutcome32a = handleGetFromOutcome(); 1090 // fromOutcome has no post constraints 1091 this.__fromOutcome32a = fromOutcome32a; 1092 if (isMetafacadePropertyCachingEnabled()) 1093 { 1094 this.__fromOutcome32aSet = true; 1095 } 1096 } 1097 return fromOutcome32a; 1098 } 1099 1100 /** 1101 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#isWarningMessagesPresent() 1102 * @return boolean 1103 */ 1104 protected abstract boolean handleIsWarningMessagesPresent(); 1105 1106 private boolean __warningMessagesPresent33a; 1107 private boolean __warningMessagesPresent33aSet = false; 1108 1109 /** 1110 * Whether or not any warning messages are present. 1111 * @return (boolean)handleIsWarningMessagesPresent() 1112 */ 1113 public final boolean isWarningMessagesPresent() 1114 { 1115 boolean warningMessagesPresent33a = this.__warningMessagesPresent33a; 1116 if (!this.__warningMessagesPresent33aSet) 1117 { 1118 // warningMessagesPresent has no pre constraints 1119 warningMessagesPresent33a = handleIsWarningMessagesPresent(); 1120 // warningMessagesPresent has no post constraints 1121 this.__warningMessagesPresent33a = warningMessagesPresent33a; 1122 if (isMetafacadePropertyCachingEnabled()) 1123 { 1124 this.__warningMessagesPresent33aSet = true; 1125 } 1126 } 1127 return warningMessagesPresent33a; 1128 } 1129 1130 /** 1131 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getWarningMessages() 1132 * @return Map 1133 */ 1134 protected abstract Map handleGetWarningMessages(); 1135 1136 private Map __warningMessages34a; 1137 private boolean __warningMessages34aSet = false; 1138 1139 /** 1140 * Any messages used to indicate a warning. 1141 * @return (Map)handleGetWarningMessages() 1142 */ 1143 public final Map getWarningMessages() 1144 { 1145 Map warningMessages34a = this.__warningMessages34a; 1146 if (!this.__warningMessages34aSet) 1147 { 1148 // warningMessages has no pre constraints 1149 warningMessages34a = handleGetWarningMessages(); 1150 // warningMessages has no post constraints 1151 this.__warningMessages34a = warningMessages34a; 1152 if (isMetafacadePropertyCachingEnabled()) 1153 { 1154 this.__warningMessages34aSet = true; 1155 } 1156 } 1157 return warningMessages34a; 1158 } 1159 1160 /** 1161 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#isSuccessMessagesPresent() 1162 * @return boolean 1163 */ 1164 protected abstract boolean handleIsSuccessMessagesPresent(); 1165 1166 private boolean __successMessagesPresent35a; 1167 private boolean __successMessagesPresent35aSet = false; 1168 1169 /** 1170 * Indicates whether or not any success messags are present. 1171 * @return (boolean)handleIsSuccessMessagesPresent() 1172 */ 1173 public final boolean isSuccessMessagesPresent() 1174 { 1175 boolean successMessagesPresent35a = this.__successMessagesPresent35a; 1176 if (!this.__successMessagesPresent35aSet) 1177 { 1178 // successMessagesPresent has no pre constraints 1179 successMessagesPresent35a = handleIsSuccessMessagesPresent(); 1180 // successMessagesPresent has no post constraints 1181 this.__successMessagesPresent35a = successMessagesPresent35a; 1182 if (isMetafacadePropertyCachingEnabled()) 1183 { 1184 this.__successMessagesPresent35aSet = true; 1185 } 1186 } 1187 return successMessagesPresent35a; 1188 } 1189 1190 /** 1191 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getSuccessMessages() 1192 * @return Map 1193 */ 1194 protected abstract Map handleGetSuccessMessages(); 1195 1196 private Map __successMessages36a; 1197 private boolean __successMessages36aSet = false; 1198 1199 /** 1200 * Messages used to indicate successful execution. 1201 * @return (Map)handleGetSuccessMessages() 1202 */ 1203 public final Map getSuccessMessages() 1204 { 1205 Map successMessages36a = this.__successMessages36a; 1206 if (!this.__successMessages36aSet) 1207 { 1208 // successMessages has no pre constraints 1209 successMessages36a = handleGetSuccessMessages(); 1210 // successMessages has no post constraints 1211 this.__successMessages36a = successMessages36a; 1212 if (isMetafacadePropertyCachingEnabled()) 1213 { 1214 this.__successMessages36aSet = true; 1215 } 1216 } 1217 return successMessages36a; 1218 } 1219 1220 /** 1221 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#isNeedsFileUpload() 1222 * @return boolean 1223 */ 1224 protected abstract boolean handleIsNeedsFileUpload(); 1225 1226 private boolean __needsFileUpload37a; 1227 private boolean __needsFileUpload37aSet = false; 1228 1229 /** 1230 * TODO: Model Documentation for 1231 * org.andromda.cartridges.jsf.metafacades.JSFAction.needsFileUpload 1232 * @return (boolean)handleIsNeedsFileUpload() 1233 */ 1234 public final boolean isNeedsFileUpload() 1235 { 1236 boolean needsFileUpload37a = this.__needsFileUpload37a; 1237 if (!this.__needsFileUpload37aSet) 1238 { 1239 // needsFileUpload has no pre constraints 1240 needsFileUpload37a = handleIsNeedsFileUpload(); 1241 // needsFileUpload has no post constraints 1242 this.__needsFileUpload37a = needsFileUpload37a; 1243 if (isMetafacadePropertyCachingEnabled()) 1244 { 1245 this.__needsFileUpload37aSet = true; 1246 } 1247 } 1248 return needsFileUpload37a; 1249 } 1250 1251 /** 1252 * @see org.andromda.cartridges.jsf.metafacades.JSFAction#getTriggerMethodName() 1253 * @return String 1254 */ 1255 protected abstract String handleGetTriggerMethodName(); 1256 1257 private String __triggerMethodName38a; 1258 private boolean __triggerMethodName38aSet = false; 1259 1260 /** 1261 * The name of the method to be executed when this action is triggered. 1262 * @return (String)handleGetTriggerMethodName() 1263 */ 1264 public final String getTriggerMethodName() 1265 { 1266 String triggerMethodName38a = this.__triggerMethodName38a; 1267 if (!this.__triggerMethodName38aSet) 1268 { 1269 // triggerMethodName has no pre constraints 1270 triggerMethodName38a = handleGetTriggerMethodName(); 1271 // triggerMethodName has no post constraints 1272 this.__triggerMethodName38a = triggerMethodName38a; 1273 if (isMetafacadePropertyCachingEnabled()) 1274 { 1275 this.__triggerMethodName38aSet = true; 1276 } 1277 } 1278 return triggerMethodName38a; 1279 } 1280 1281 // ------------- associations ------------------ 1282 1283 private JSFParameter __getTableLinkParameter1r; 1284 private boolean __getTableLinkParameter1rSet = false; 1285 1286 /** 1287 * Represents an action taken during a "front-end" event execution on a JSF application. 1288 * @return (JSFParameter)handleGetTableLinkParameter() 1289 */ 1290 public final JSFParameter getTableLinkParameter() 1291 { 1292 JSFParameter getTableLinkParameter1r = this.__getTableLinkParameter1r; 1293 if (!this.__getTableLinkParameter1rSet) 1294 { 1295 // jSFAction has no pre constraints 1296 Object result = handleGetTableLinkParameter(); 1297 MetafacadeBase shieldedResult = this.shieldedElement(result); 1298 try 1299 { 1300 getTableLinkParameter1r = (JSFParameter)shieldedResult; 1301 } 1302 catch (ClassCastException ex) 1303 { 1304 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1305 JSFActionLogic.logger.warn("incorrect metafacade cast for JSFActionLogic.getTableLinkParameter JSFParameter " + result + ": " + shieldedResult); 1306 } 1307 // jSFAction has no post constraints 1308 this.__getTableLinkParameter1r = getTableLinkParameter1r; 1309 if (isMetafacadePropertyCachingEnabled()) 1310 { 1311 this.__getTableLinkParameter1rSet = true; 1312 } 1313 } 1314 return getTableLinkParameter1r; 1315 } 1316 1317 /** 1318 * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type 1319 * @return Object 1320 */ 1321 protected abstract Object handleGetTableLinkParameter(); 1322 1323 private List<JSFParameter> __getHiddenParameters2r; 1324 private boolean __getHiddenParameters2rSet = false; 1325 1326 /** 1327 * Represents an action taken during a "front-end" event execution on a JSF application. 1328 * @return (List<JSFParameter>)handleGetHiddenParameters() 1329 */ 1330 public final List<JSFParameter> getHiddenParameters() 1331 { 1332 List<JSFParameter> getHiddenParameters2r = this.__getHiddenParameters2r; 1333 if (!this.__getHiddenParameters2rSet) 1334 { 1335 // jSFAction has no pre constraints 1336 List result = handleGetHiddenParameters(); 1337 List shieldedResult = this.shieldedElements(result); 1338 try 1339 { 1340 getHiddenParameters2r = (List<JSFParameter>)shieldedResult; 1341 } 1342 catch (ClassCastException ex) 1343 { 1344 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1345 JSFActionLogic.logger.warn("incorrect metafacade cast for JSFActionLogic.getHiddenParameters List<JSFParameter> " + result + ": " + shieldedResult); 1346 } 1347 // jSFAction has no post constraints 1348 this.__getHiddenParameters2r = getHiddenParameters2r; 1349 if (isMetafacadePropertyCachingEnabled()) 1350 { 1351 this.__getHiddenParameters2rSet = true; 1352 } 1353 } 1354 return getHiddenParameters2r; 1355 } 1356 1357 /** 1358 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type 1359 * @return List 1360 */ 1361 protected abstract List handleGetHiddenParameters(); 1362 1363 /** 1364 * @return true 1365 * @see FrontEndAction 1366 */ 1367 public boolean isFrontEndActionMetaType() 1368 { 1369 return true; 1370 } 1371 1372 /** 1373 * @return true 1374 * @see FrontEndForward 1375 */ 1376 public boolean isFrontEndForwardMetaType() 1377 { 1378 return true; 1379 } 1380 1381 /** 1382 * @return true 1383 * @see org.andromda.metafacades.uml.TransitionFacade 1384 */ 1385 public boolean isTransitionFacadeMetaType() 1386 { 1387 return true; 1388 } 1389 1390 /** 1391 * @return true 1392 * @see ModelElementFacade 1393 */ 1394 public boolean isModelElementFacadeMetaType() 1395 { 1396 return true; 1397 } 1398 1399 // ----------- delegates to FrontEndAction ------------ 1400 /** 1401 * Finds the parameter on this action having the given name, if no parameter is found, null is 1402 * returned instead. 1403 * @see FrontEndAction#findParameter(String name) 1404 */ 1405 public ParameterFacade findParameter(String name) 1406 { 1407 return this.getSuperFrontEndAction().findParameter(name); 1408 } 1409 1410 /** 1411 * All action forwards for this foward. Each action forward either calls a view or another 1412 * use-case (which is essentially an action). 1413 * @see FrontEndAction#getActionForwards() 1414 */ 1415 public List<FrontEndForward> getActionForwards() 1416 { 1417 return this.getSuperFrontEndAction().getActionForwards(); 1418 } 1419 1420 /** 1421 * All action states visited by this action. 1422 * @see FrontEndAction#getActionStates() 1423 */ 1424 public List<FrontEndActionState> getActionStates() 1425 { 1426 return this.getSuperFrontEndAction().getActionStates(); 1427 } 1428 1429 /** 1430 * The controller that will handle the execution of this front-end action. This controller is 1431 * set as the context of the activity graph (and therefore also of the use-case). 1432 * @see FrontEndAction#getController() 1433 */ 1434 public FrontEndController getController() 1435 { 1436 return this.getSuperFrontEndAction().getController(); 1437 } 1438 1439 /** 1440 * All the transitions coming out of decision points. These transitions should all carry guards. 1441 * @see FrontEndAction#getDecisionTransitions() 1442 */ 1443 public List<FrontEndForward> getDecisionTransitions() 1444 { 1445 return this.getSuperFrontEndAction().getDecisionTransitions(); 1446 } 1447 1448 /** 1449 * The controller operations to which this action defers, the order is preserved. 1450 * @see FrontEndAction#getDeferredOperations() 1451 */ 1452 public List<FrontEndControllerOperation> getDeferredOperations() 1453 { 1454 return this.getSuperFrontEndAction().getDeferredOperations(); 1455 } 1456 1457 /** 1458 * Form fields for this action. Form fields are those parameters that can be altered by the user 1459 * on a corresponding view at runtime. 1460 * @see FrontEndAction#getFormFields() 1461 */ 1462 public List<FrontEndParameter> getFormFields() 1463 { 1464 return this.getSuperFrontEndAction().getFormFields(); 1465 } 1466 1467 /** 1468 * The StateVertex (FrontEndView or PseudostateFacade) on which this action can be triggered. 1469 * @see FrontEndAction#getInput() 1470 */ 1471 public StateVertexFacade getInput() 1472 { 1473 return this.getSuperFrontEndAction().getInput(); 1474 } 1475 1476 /** 1477 * All parameters sent by this "front-end" action. 1478 * @see FrontEndAction#getParameters() 1479 */ 1480 public List<FrontEndParameter> getParameters() 1481 { 1482 return this.getSuperFrontEndAction().getParameters(); 1483 } 1484 1485 /** 1486 * All views that can be possibly targetted by triggering this action. 1487 * @see FrontEndAction#getTargetViews() 1488 */ 1489 public List<FrontEndView> getTargetViews() 1490 { 1491 return this.getSuperFrontEndAction().getTargetViews(); 1492 } 1493 1494 /** 1495 * All the transitions that make up this action, this directly maps onto the forwards. 1496 * @see FrontEndAction#getTransitions() 1497 */ 1498 public List<FrontEndForward> getTransitions() 1499 { 1500 return this.getSuperFrontEndAction().getTransitions(); 1501 } 1502 1503 /** 1504 * Indicates if this action represents the beginning of the front-end use case or not. 1505 * @see FrontEndAction#isUseCaseStart() 1506 */ 1507 public boolean isUseCaseStart() 1508 { 1509 return this.getSuperFrontEndAction().isUseCaseStart(); 1510 } 1511 1512 /** 1513 * The method name used to delegate to this forward. 1514 * @see FrontEndForward#getActionMethodName() 1515 */ 1516 public String getActionMethodName() 1517 { 1518 return this.getSuperFrontEndAction().getActionMethodName(); 1519 } 1520 1521 /** 1522 * The front-end actions directly containing this front-end forward. 1523 * @see FrontEndForward#getActions() 1524 */ 1525 public List<FrontEndAction> getActions() 1526 { 1527 return this.getSuperFrontEndAction().getActions(); 1528 } 1529 1530 /** 1531 * The trigger for this front-end forward. 1532 * @see FrontEndForward#getDecisionTrigger() 1533 */ 1534 public FrontEndEvent getDecisionTrigger() 1535 { 1536 return this.getSuperFrontEndAction().getDecisionTrigger(); 1537 } 1538 1539 /** 1540 * Tthe set of parameter used during transport in this forward. 1541 * @see FrontEndForward#getForwardParameters() 1542 */ 1543 public List<FrontEndParameter> getForwardParameters() 1544 { 1545 return this.getSuperFrontEndAction().getForwardParameters(); 1546 } 1547 1548 /** 1549 * The activity graph which holds this forward if the graph is contained in a FrontEndUseCase. 1550 * @see FrontEndForward#getFrontEndActivityGraph() 1551 */ 1552 public FrontEndActivityGraph getFrontEndActivityGraph() 1553 { 1554 return this.getSuperFrontEndAction().getFrontEndActivityGraph(); 1555 } 1556 1557 /** 1558 * The operation to which is called during execution of this front-end forward. 1559 * @see FrontEndForward#getOperationCall() 1560 */ 1561 public FrontEndControllerOperation getOperationCall() 1562 { 1563 return this.getSuperFrontEndAction().getOperationCall(); 1564 } 1565 1566 /** 1567 * The use case in which this forward is contained. 1568 * @see FrontEndForward#getUseCase() 1569 */ 1570 public FrontEndUseCase getUseCase() 1571 { 1572 return this.getSuperFrontEndAction().getUseCase(); 1573 } 1574 1575 /** 1576 * Indicates if this forward is contained in a FrontEndUseCase. 1577 * @see FrontEndForward#isContainedInFrontEndUseCase() 1578 */ 1579 public boolean isContainedInFrontEndUseCase() 1580 { 1581 return this.getSuperFrontEndAction().isContainedInFrontEndUseCase(); 1582 } 1583 1584 /** 1585 * Indicates if this action directly targets a "front-end" view, false otherwise. 1586 * @see FrontEndForward#isEnteringView() 1587 */ 1588 public boolean isEnteringView() 1589 { 1590 return this.getSuperFrontEndAction().isEnteringView(); 1591 } 1592 1593 /** 1594 * Indicates if this forward (transition) is coming out of a front-end view. 1595 * @see FrontEndForward#isExitingView() 1596 */ 1597 public boolean isExitingView() 1598 { 1599 return this.getSuperFrontEndAction().isExitingView(); 1600 } 1601 1602 /** 1603 * Copies all tagged values from the given ModelElementFacade to this model element facade. 1604 * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element) 1605 */ 1606 public void copyTaggedValues(ModelElementFacade element) 1607 { 1608 this.getSuperFrontEndAction().copyTaggedValues(element); 1609 } 1610 1611 /** 1612 * Finds the tagged value with the specified 'tagName'. In case there are more values the first 1613 * one found will be returned. 1614 * @see ModelElementFacade#findTaggedValue(String tagName) 1615 */ 1616 public Object findTaggedValue(String tagName) 1617 { 1618 return this.getSuperFrontEndAction().findTaggedValue(tagName); 1619 } 1620 1621 /** 1622 * Returns all the values for the tagged value with the specified name. The returned collection 1623 * will contains only String instances, or will be empty. Never null. 1624 * @see ModelElementFacade#findTaggedValues(String tagName) 1625 */ 1626 public Collection<Object> findTaggedValues(String tagName) 1627 { 1628 return this.getSuperFrontEndAction().findTaggedValues(tagName); 1629 } 1630 1631 /** 1632 * Returns the fully qualified name of the model element. The fully qualified name includes 1633 * complete package qualified name of the underlying model element. The templates parameter will 1634 * be replaced by the correct one given the binding relation of the parameter to this element. 1635 * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement) 1636 */ 1637 public String getBindedFullyQualifiedName(ModelElementFacade bindedElement) 1638 { 1639 return this.getSuperFrontEndAction().getBindedFullyQualifiedName(bindedElement); 1640 } 1641 1642 /** 1643 * Gets all constraints belonging to the model element. 1644 * @see ModelElementFacade#getConstraints() 1645 */ 1646 public Collection<ConstraintFacade> getConstraints() 1647 { 1648 return this.getSuperFrontEndAction().getConstraints(); 1649 } 1650 1651 /** 1652 * Returns the constraints of the argument kind that have been placed onto this model. Typical 1653 * kinds are "inv", "pre" and "post". Other kinds are possible. 1654 * @see ModelElementFacade#getConstraints(String kind) 1655 */ 1656 public Collection<ConstraintFacade> getConstraints(String kind) 1657 { 1658 return this.getSuperFrontEndAction().getConstraints(kind); 1659 } 1660 1661 /** 1662 * Gets the documentation for the model element, The indent argument is prefixed to each line. 1663 * By default this method wraps lines after 64 characters. 1664 * This method is equivalent to <code>getDocumentation(indent, 64)</code>. 1665 * @see ModelElementFacade#getDocumentation(String indent) 1666 */ 1667 public String getDocumentation(String indent) 1668 { 1669 return this.getSuperFrontEndAction().getDocumentation(indent); 1670 } 1671 1672 /** 1673 * This method returns the documentation for this model element, with the lines wrapped after 1674 * the specified number of characters, values of less than 1 will indicate no line wrapping is 1675 * required. By default paragraphs are returned as HTML. 1676 * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>. 1677 * @see ModelElementFacade#getDocumentation(String indent, int lineLength) 1678 */ 1679 public String getDocumentation(String indent, int lineLength) 1680 { 1681 return this.getSuperFrontEndAction().getDocumentation(indent, lineLength); 1682 } 1683 1684 /** 1685 * This method returns the documentation for this model element, with the lines wrapped after 1686 * the specified number of characters, values of less than 1 will indicate no line wrapping is 1687 * required. HTML style determines if HTML Escaping is applied. 1688 * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle) 1689 */ 1690 public String getDocumentation(String indent, int lineLength, boolean htmlStyle) 1691 { 1692 return this.getSuperFrontEndAction().getDocumentation(indent, lineLength, htmlStyle); 1693 } 1694 1695 /** 1696 * The fully qualified name of this model element. 1697 * @see ModelElementFacade#getFullyQualifiedName() 1698 */ 1699 public String getFullyQualifiedName() 1700 { 1701 return this.getSuperFrontEndAction().getFullyQualifiedName(); 1702 } 1703 1704 /** 1705 * Returns the fully qualified name of the model element. The fully qualified name includes 1706 * complete package qualified name of the underlying model element. If modelName is true, then 1707 * the original name of the model element (the name contained within the model) will be the name 1708 * returned, otherwise a name from a language mapping will be returned. 1709 * @see ModelElementFacade#getFullyQualifiedName(boolean modelName) 1710 */ 1711 public String getFullyQualifiedName(boolean modelName) 1712 { 1713 return this.getSuperFrontEndAction().getFullyQualifiedName(modelName); 1714 } 1715 1716 /** 1717 * Returns the fully qualified name as a path, the returned value always starts with out a slash 1718 * '/'. 1719 * @see ModelElementFacade#getFullyQualifiedNamePath() 1720 */ 1721 public String getFullyQualifiedNamePath() 1722 { 1723 return this.getSuperFrontEndAction().getFullyQualifiedNamePath(); 1724 } 1725 1726 /** 1727 * Gets the unique identifier of the underlying model element. 1728 * @see ModelElementFacade#getId() 1729 */ 1730 public String getId() 1731 { 1732 return this.getSuperFrontEndAction().getId(); 1733 } 1734 1735 /** 1736 * UML2: Retrieves the keywords for this element. Used to modify implementation properties which 1737 * are not represented by other properties, i.e. native, transient, volatile, synchronized, 1738 * (added annotations) override, deprecated. Can also be used to suppress compiler warnings: 1739 * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require 1740 * JDK5 compiler level. 1741 * @see ModelElementFacade#getKeywords() 1742 */ 1743 public Collection<String> getKeywords() 1744 { 1745 return this.getSuperFrontEndAction().getKeywords(); 1746 } 1747 1748 /** 1749 * UML2: Retrieves a localized label for this named element. 1750 * @see ModelElementFacade#getLabel() 1751 */ 1752 public String getLabel() 1753 { 1754 return this.getSuperFrontEndAction().getLabel(); 1755 } 1756 1757 /** 1758 * The language mappings that have been set for this model element. 1759 * @see ModelElementFacade#getLanguageMappings() 1760 */ 1761 public TypeMappings getLanguageMappings() 1762 { 1763 return this.getSuperFrontEndAction().getLanguageMappings(); 1764 } 1765 1766 /** 1767 * Return the model containing this model element (multiple models may be loaded and processed 1768 * at the same time). 1769 * @see ModelElementFacade#getModel() 1770 */ 1771 public ModelFacade getModel() 1772 { 1773 return this.getSuperFrontEndAction().getModel(); 1774 } 1775 1776 /** 1777 * The name of the model element. 1778 * @see ModelElementFacade#getName() 1779 */ 1780 public String getName() 1781 { 1782 return this.getSuperFrontEndAction().getName(); 1783 } 1784 1785 /** 1786 * Gets the package to which this model element belongs. 1787 * @see ModelElementFacade#getPackage() 1788 */ 1789 public ModelElementFacade getPackage() 1790 { 1791 return this.getSuperFrontEndAction().getPackage(); 1792 } 1793 1794 /** 1795 * The name of this model element's package. 1796 * @see ModelElementFacade#getPackageName() 1797 */ 1798 public String getPackageName() 1799 { 1800 return this.getSuperFrontEndAction().getPackageName(); 1801 } 1802 1803 /** 1804 * Gets the package name (optionally providing the ability to retrieve the model name and not 1805 * the mapped name). 1806 * @see ModelElementFacade#getPackageName(boolean modelName) 1807 */ 1808 public String getPackageName(boolean modelName) 1809 { 1810 return this.getSuperFrontEndAction().getPackageName(modelName); 1811 } 1812 1813 /** 1814 * Returns the package as a path, the returned value always starts with out a slash '/'. 1815 * @see ModelElementFacade#getPackagePath() 1816 */ 1817 public String getPackagePath() 1818 { 1819 return this.getSuperFrontEndAction().getPackagePath(); 1820 } 1821 1822 /** 1823 * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the 1824 * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from 1825 * the names of the containing namespaces starting at the root of the hierarchy and ending with 1826 * the name of the NamedElement itself. 1827 * @see ModelElementFacade#getQualifiedName() 1828 */ 1829 public String getQualifiedName() 1830 { 1831 return this.getSuperFrontEndAction().getQualifiedName(); 1832 } 1833 1834 /** 1835 * Gets the root package for the model element. 1836 * @see ModelElementFacade#getRootPackage() 1837 */ 1838 public PackageFacade getRootPackage() 1839 { 1840 return this.getSuperFrontEndAction().getRootPackage(); 1841 } 1842 1843 /** 1844 * Gets the dependencies for which this model element is the source. 1845 * @see ModelElementFacade#getSourceDependencies() 1846 */ 1847 public Collection<DependencyFacade> getSourceDependencies() 1848 { 1849 return this.getSuperFrontEndAction().getSourceDependencies(); 1850 } 1851 1852 /** 1853 * If this model element is the context of an activity graph, this represents that activity 1854 * graph. 1855 * @see ModelElementFacade#getStateMachineContext() 1856 */ 1857 public StateMachineFacade getStateMachineContext() 1858 { 1859 return this.getSuperFrontEndAction().getStateMachineContext(); 1860 } 1861 1862 /** 1863 * The collection of ALL stereotype names for this model element. 1864 * @see ModelElementFacade#getStereotypeNames() 1865 */ 1866 public Collection<String> getStereotypeNames() 1867 { 1868 return this.getSuperFrontEndAction().getStereotypeNames(); 1869 } 1870 1871 /** 1872 * Gets all stereotypes for this model element. 1873 * @see ModelElementFacade#getStereotypes() 1874 */ 1875 public Collection<StereotypeFacade> getStereotypes() 1876 { 1877 return this.getSuperFrontEndAction().getStereotypes(); 1878 } 1879 1880 /** 1881 * Return the TaggedValues associated with this model element, under all stereotypes. 1882 * @see ModelElementFacade#getTaggedValues() 1883 */ 1884 public Collection<TaggedValueFacade> getTaggedValues() 1885 { 1886 return this.getSuperFrontEndAction().getTaggedValues(); 1887 } 1888 1889 /** 1890 * Gets the dependencies for which this model element is the target. 1891 * @see ModelElementFacade#getTargetDependencies() 1892 */ 1893 public Collection<DependencyFacade> getTargetDependencies() 1894 { 1895 return this.getSuperFrontEndAction().getTargetDependencies(); 1896 } 1897 1898 /** 1899 * Get the template parameter for this model element having the parameterName 1900 * @see ModelElementFacade#getTemplateParameter(String parameterName) 1901 */ 1902 public Object getTemplateParameter(String parameterName) 1903 { 1904 return this.getSuperFrontEndAction().getTemplateParameter(parameterName); 1905 } 1906 1907 /** 1908 * Get the template parameters for this model element 1909 * @see ModelElementFacade#getTemplateParameters() 1910 */ 1911 public Collection<TemplateParameterFacade> getTemplateParameters() 1912 { 1913 return this.getSuperFrontEndAction().getTemplateParameters(); 1914 } 1915 1916 /** 1917 * The visibility (i.e. public, private, protected or package) of the model element, will 1918 * attempt a lookup for these values in the language mappings (if any). 1919 * @see ModelElementFacade#getVisibility() 1920 */ 1921 public String getVisibility() 1922 { 1923 return this.getSuperFrontEndAction().getVisibility(); 1924 } 1925 1926 /** 1927 * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance 1928 * is taken into account when searching for the stereotype), false otherwise. 1929 * @see ModelElementFacade#hasExactStereotype(String stereotypeName) 1930 */ 1931 public boolean hasExactStereotype(String stereotypeName) 1932 { 1933 return this.getSuperFrontEndAction().hasExactStereotype(stereotypeName); 1934 } 1935 1936 /** 1937 * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma, 1938 * pipe, semicolon, or << >> 1939 * @see ModelElementFacade#hasKeyword(String keywordName) 1940 */ 1941 public boolean hasKeyword(String keywordName) 1942 { 1943 return this.getSuperFrontEndAction().hasKeyword(keywordName); 1944 } 1945 1946 /** 1947 * Returns true if the model element has the specified stereotype. If the stereotype itself 1948 * does not match, then a search will be made up the stereotype inheritance hierarchy, and if 1949 * one of the stereotype's ancestors has a matching name this method will return true, false 1950 * otherwise. 1951 * For example, if we have a certain stereotype called <<exception>> and a model element has a 1952 * stereotype called <<applicationException>> which extends <<exception>>, when calling this 1953 * method with 'stereotypeName' defined as 'exception' the method would return true since 1954 * <<applicationException>> inherits from <<exception>>. If you want to check if the model 1955 * element has the exact stereotype, then use the method 'hasExactStereotype' instead. 1956 * @see ModelElementFacade#hasStereotype(String stereotypeName) 1957 */ 1958 public boolean hasStereotype(String stereotypeName) 1959 { 1960 return this.getSuperFrontEndAction().hasStereotype(stereotypeName); 1961 } 1962 1963 /** 1964 * True if there are target dependencies from this element that are instances of BindingFacade. 1965 * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies. 1966 * @see ModelElementFacade#isBindingDependenciesPresent() 1967 */ 1968 public boolean isBindingDependenciesPresent() 1969 { 1970 return this.getSuperFrontEndAction().isBindingDependenciesPresent(); 1971 } 1972 1973 /** 1974 * Indicates if any constraints are present on this model element. 1975 * @see ModelElementFacade#isConstraintsPresent() 1976 */ 1977 public boolean isConstraintsPresent() 1978 { 1979 return this.getSuperFrontEndAction().isConstraintsPresent(); 1980 } 1981 1982 /** 1983 * Indicates if any documentation is present on this model element. 1984 * @see ModelElementFacade#isDocumentationPresent() 1985 */ 1986 public boolean isDocumentationPresent() 1987 { 1988 return this.getSuperFrontEndAction().isDocumentationPresent(); 1989 } 1990 1991 /** 1992 * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript. 1993 * @see ModelElementFacade#isReservedWord() 1994 */ 1995 public boolean isReservedWord() 1996 { 1997 return this.getSuperFrontEndAction().isReservedWord(); 1998 } 1999 2000 /** 2001 * True is there are template parameters on this model element. For UML2, applies to Class, 2002 * Operation, Property, and Parameter. 2003 * @see ModelElementFacade#isTemplateParametersPresent() 2004 */ 2005 public boolean isTemplateParametersPresent() 2006 { 2007 return this.getSuperFrontEndAction().isTemplateParametersPresent(); 2008 } 2009 2010 /** 2011 * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++, 2012 * JavaScript. Contains no spaces, special characters etc. Constraint always applied on 2013 * Enumerations and Interfaces, optionally applies on other model elements. 2014 * @see ModelElementFacade#isValidIdentifierName() 2015 */ 2016 public boolean isValidIdentifierName() 2017 { 2018 return this.getSuperFrontEndAction().isValidIdentifierName(); 2019 } 2020 2021 /** 2022 * Searches for the constraint with the specified 'name' on this model element, and if found 2023 * translates it using the specified 'translation' from a translation library discovered by the 2024 * framework. 2025 * @see ModelElementFacade#translateConstraint(String name, String translation) 2026 */ 2027 public String translateConstraint(String name, String translation) 2028 { 2029 return this.getSuperFrontEndAction().translateConstraint(name, translation); 2030 } 2031 2032 /** 2033 * Translates all constraints belonging to this model element with the given 'translation'. 2034 * @see ModelElementFacade#translateConstraints(String translation) 2035 */ 2036 public String[] translateConstraints(String translation) 2037 { 2038 return this.getSuperFrontEndAction().translateConstraints(translation); 2039 } 2040 2041 /** 2042 * Translates the constraints of the specified 'kind' belonging to this model element. 2043 * @see ModelElementFacade#translateConstraints(String kind, String translation) 2044 */ 2045 public String[] translateConstraints(String kind, String translation) 2046 { 2047 return this.getSuperFrontEndAction().translateConstraints(kind, translation); 2048 } 2049 2050 /** 2051 * An action is a named element that is the fundamental unit of executable functionality. The 2052 * execution 2053 * of an action represents some transformation or processing in the modeled system, be it a 2054 * computer 2055 * system or otherwise. An action represents a single step within an activity, that is, one that 2056 * is not 2057 * further decomposed within the activity. An action has pre- and post-conditions. 2058 * @see org.andromda.metafacades.uml.TransitionFacade#getEffect() 2059 */ 2060 public ActionFacade getEffect() 2061 { 2062 return this.getSuperFrontEndAction().getEffect(); 2063 } 2064 2065 /** 2066 * A representation of the model object 'Constraint'. A condition or restriction expressed in 2067 * natural 2068 * language text or in a machine readable language for the purpose of declaring some of the 2069 * semantics 2070 * of an element. 2071 * @see org.andromda.metafacades.uml.TransitionFacade#getGuard() 2072 */ 2073 public GuardFacade getGuard() 2074 { 2075 return this.getSuperFrontEndAction().getGuard(); 2076 } 2077 2078 /** 2079 * A representation of the model object 'Vertex'. An abstraction of a node in a state machine 2080 * graph. In 2081 * general, it can be the source or destination of any number of transitions. 2082 * @see org.andromda.metafacades.uml.TransitionFacade#getSource() 2083 */ 2084 public StateVertexFacade getSource() 2085 { 2086 return this.getSuperFrontEndAction().getSource(); 2087 } 2088 2089 /** 2090 * A representation of the model object 'Vertex'. An abstraction of a node in a state machine 2091 * graph. In 2092 * general, it can be the source or destination of any number of transitions. 2093 * @see org.andromda.metafacades.uml.TransitionFacade#getTarget() 2094 */ 2095 public StateVertexFacade getTarget() 2096 { 2097 return this.getSuperFrontEndAction().getTarget(); 2098 } 2099 2100 /** 2101 * If a trigger is present on this transition, this event represents that trigger. 2102 * @see org.andromda.metafacades.uml.TransitionFacade#getTrigger() 2103 */ 2104 public EventFacade getTrigger() 2105 { 2106 return this.getSuperFrontEndAction().getTrigger(); 2107 } 2108 2109 /** 2110 * TODO: Model Documentation for 2111 * org.andromda.metafacades.uml.TransitionFacade.enteringActionState 2112 * @see org.andromda.metafacades.uml.TransitionFacade#isEnteringActionState() 2113 */ 2114 public boolean isEnteringActionState() 2115 { 2116 return this.getSuperFrontEndAction().isEnteringActionState(); 2117 } 2118 2119 /** 2120 * TODO: Model Documentation for 2121 * org.andromda.metafacades.uml.TransitionFacade.enteringDecisionPoint 2122 * @see org.andromda.metafacades.uml.TransitionFacade#isEnteringDecisionPoint() 2123 */ 2124 public boolean isEnteringDecisionPoint() 2125 { 2126 return this.getSuperFrontEndAction().isEnteringDecisionPoint(); 2127 } 2128 2129 /** 2130 * TODO: Model Documentation for 2131 * org.andromda.metafacades.uml.TransitionFacade.enteringFinalState 2132 * @see org.andromda.metafacades.uml.TransitionFacade#isEnteringFinalState() 2133 */ 2134 public boolean isEnteringFinalState() 2135 { 2136 return this.getSuperFrontEndAction().isEnteringFinalState(); 2137 } 2138 2139 /** 2140 * TODO: Model Documentation for 2141 * org.andromda.metafacades.uml.TransitionFacade.exitingActionState 2142 * @see org.andromda.metafacades.uml.TransitionFacade#isExitingActionState() 2143 */ 2144 public boolean isExitingActionState() 2145 { 2146 return this.getSuperFrontEndAction().isExitingActionState(); 2147 } 2148 2149 /** 2150 * TODO: Model Documentation for 2151 * org.andromda.metafacades.uml.TransitionFacade.exitingDecisionPoint 2152 * @see org.andromda.metafacades.uml.TransitionFacade#isExitingDecisionPoint() 2153 */ 2154 public boolean isExitingDecisionPoint() 2155 { 2156 return this.getSuperFrontEndAction().isExitingDecisionPoint(); 2157 } 2158 2159 /** 2160 * TODO: Model Documentation for 2161 * org.andromda.metafacades.uml.TransitionFacade.exitingInitialState 2162 * @see org.andromda.metafacades.uml.TransitionFacade#isExitingInitialState() 2163 */ 2164 public boolean isExitingInitialState() 2165 { 2166 return this.getSuperFrontEndAction().isExitingInitialState(); 2167 } 2168 2169 /** 2170 * TODO: Model Documentation for org.andromda.metafacades.uml.TransitionFacade.triggerPresent 2171 * @see org.andromda.metafacades.uml.TransitionFacade#isTriggerPresent() 2172 */ 2173 public boolean isTriggerPresent() 2174 { 2175 return this.getSuperFrontEndAction().isTriggerPresent(); 2176 } 2177 2178 /** 2179 * @see MetafacadeBase#initialize() 2180 */ 2181 @Override 2182 public void initialize() 2183 { 2184 this.getSuperFrontEndAction().initialize(); 2185 } 2186 2187 /** 2188 * @return Object getSuperFrontEndAction().getValidationOwner() 2189 * @see MetafacadeBase#getValidationOwner() 2190 */ 2191 @Override 2192 public Object getValidationOwner() 2193 { 2194 Object owner = this.getSuperFrontEndAction().getValidationOwner(); 2195 return owner; 2196 } 2197 2198 /** 2199 * @return String getSuperFrontEndAction().getValidationName() 2200 * @see MetafacadeBase#getValidationName() 2201 */ 2202 @Override 2203 public String getValidationName() 2204 { 2205 String name = this.getSuperFrontEndAction().getValidationName(); 2206 return name; 2207 } 2208 2209 /** 2210 * @param validationMessages Collection<ModelValidationMessage> 2211 * @see MetafacadeBase#validateInvariants(Collection validationMessages) 2212 */ 2213 @Override 2214 public void validateInvariants(Collection<ModelValidationMessage> validationMessages) 2215 { 2216 this.getSuperFrontEndAction().validateInvariants(validationMessages); 2217 } 2218 2219 /** 2220 * The property that stores the name of the metafacade. 2221 */ 2222 private static final String NAME_PROPERTY = "name"; 2223 private static final String FQNAME_PROPERTY = "fullyQualifiedName"; 2224 2225 /** 2226 * @see Object#toString() 2227 */ 2228 @Override 2229 public String toString() 2230 { 2231 final StringBuilder toString = new StringBuilder(this.getClass().getName()); 2232 toString.append("["); 2233 try 2234 { 2235 toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY)); 2236 } 2237 catch (final Throwable tryAgain) 2238 { 2239 try 2240 { 2241 toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY)); 2242 } 2243 catch (final Throwable ignore) 2244 { 2245 // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property 2246 } 2247 } 2248 toString.append("]"); 2249 return toString.toString(); 2250 } 2251}