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