001// license-header java merge-point 002// 003// Attention: generated code (by MetafacadeLogic.vsl) - do not modify! 004// 005package org.andromda.cartridges.bpm4struts.metafacades; 006 007import java.util.Collection; 008import java.util.List; 009import org.andromda.core.metafacade.MetafacadeBase; 010import org.andromda.core.metafacade.ModelValidationMessage; 011import org.andromda.translation.ocl.validation.OCLCollections; 012import org.andromda.translation.ocl.validation.OCLIntrospector; 013import org.andromda.translation.ocl.validation.OCLResultEnsurer; 014import org.apache.log4j.Logger; 015 016/** 017 * Represents a Struts action. Such an action typically is associated with a form bean. 018 * This action model element extends a transition, but the actual logic contained by the action 019 * envelops all action states called, until either a final state or JSP page is reached. 020 * MetafacadeLogic for StrutsAction 021 * 022 * @see StrutsAction 023 */ 024public abstract class StrutsActionLogic 025 extends StrutsForwardLogicImpl 026 implements StrutsAction 027{ 028 /** 029 * The underlying UML object 030 * @see Object 031 */ 032 protected Object metaObject; 033 034 /** Create Metafacade implementation instance using the MetafacadeFactory from the context 035 * @param metaObjectIn 036 * @param context 037 */ 038 protected StrutsActionLogic(Object metaObjectIn, String context) 039 { 040 super(metaObjectIn, getContext(context)); 041 this.metaObject = metaObjectIn; 042 } 043 044 /** 045 * The logger instance. 046 */ 047 private static final Logger logger = Logger.getLogger(StrutsActionLogic.class); 048 049 /** 050 * Gets the context for this metafacade logic instance. 051 * @param context String. Set to StrutsAction if null 052 * @return context String 053 */ 054 private static String getContext(String context) 055 { 056 if (context == null) 057 { 058 context = "org.andromda.cartridges.bpm4struts.metafacades.StrutsAction"; 059 } 060 return context; 061 } 062 063 /** Reset context only for non-root metafacades 064 * @param context 065 */ 066 @Override 067 public void resetMetafacadeContext(String context) 068 { 069 if (!this.contextRoot) // reset context only for non-root metafacades 070 { 071 context = getContext(context); // to have same value as in original constructor call 072 setMetafacadeContext (context); 073 } 074 } 075 076 /** 077 * @return boolean true always 078 * @see StrutsAction 079 */ 080 public boolean isStrutsActionMetaType() 081 { 082 return true; 083 } 084 085 // --------------- attributes --------------------- 086 087 /** 088 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getActionName() 089 * @return String 090 */ 091 protected abstract String handleGetActionName(); 092 093 private String __actionName1a; 094 private boolean __actionName1aSet = false; 095 096 /** 097 * The action name corresponding to this action, as found in the struts deployment descriptor. 098 * The action name maps the action to a form bean. 099 * @return (String)handleGetActionName() 100 */ 101 public final String getActionName() 102 { 103 String actionName1a = this.__actionName1a; 104 if (!this.__actionName1aSet) 105 { 106 // actionName has no pre constraints 107 actionName1a = handleGetActionName(); 108 // actionName has no post constraints 109 this.__actionName1a = actionName1a; 110 if (isMetafacadePropertyCachingEnabled()) 111 { 112 this.__actionName1aSet = true; 113 } 114 } 115 return actionName1a; 116 } 117 118 /** 119 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getActionPath() 120 * @return String 121 */ 122 protected abstract String handleGetActionPath(); 123 124 private String __actionPath2a; 125 private boolean __actionPath2aSet = false; 126 127 /** 128 * Tthe action path corresponding to this action, as found in the struts deployment descriptor. 129 * The action path specifies the URL to enter in order to call the action. 130 * @return (String)handleGetActionPath() 131 */ 132 public final String getActionPath() 133 { 134 String actionPath2a = this.__actionPath2a; 135 if (!this.__actionPath2aSet) 136 { 137 // actionPath has no pre constraints 138 actionPath2a = handleGetActionPath(); 139 // actionPath has no post constraints 140 this.__actionPath2a = actionPath2a; 141 if (isMetafacadePropertyCachingEnabled()) 142 { 143 this.__actionPath2aSet = true; 144 } 145 } 146 return actionPath2a; 147 } 148 149 /** 150 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getActionInput() 151 * @return String 152 */ 153 protected abstract String handleGetActionInput(); 154 155 private String __actionInput3a; 156 private boolean __actionInput3aSet = false; 157 158 /** 159 * The action input corresponding to this action, as found in the struts deployment descriptor. 160 * The action input maps the action to the page on which it originated. 161 * @return (String)handleGetActionInput() 162 */ 163 public final String getActionInput() 164 { 165 String actionInput3a = this.__actionInput3a; 166 if (!this.__actionInput3aSet) 167 { 168 // actionInput has no pre constraints 169 actionInput3a = handleGetActionInput(); 170 // actionInput has no post constraints 171 this.__actionInput3a = actionInput3a; 172 if (isMetafacadePropertyCachingEnabled()) 173 { 174 this.__actionInput3aSet = true; 175 } 176 } 177 return actionInput3a; 178 } 179 180 /** 181 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getActionRoles() 182 * @return String 183 */ 184 protected abstract String handleGetActionRoles(); 185 186 private String __actionRoles4a; 187 private boolean __actionRoles4aSet = false; 188 189 /** 190 * The action roles corresponding to this action, as found in the struts deployment descriptor. 191 * The action roles specifiy the roles in which the user must be in order to be authorized to 192 * call the action. One of the roles must be satisfied. 193 * @return (String)handleGetActionRoles() 194 */ 195 public final String getActionRoles() 196 { 197 String actionRoles4a = this.__actionRoles4a; 198 if (!this.__actionRoles4aSet) 199 { 200 // actionRoles has no pre constraints 201 actionRoles4a = handleGetActionRoles(); 202 // actionRoles has no post constraints 203 this.__actionRoles4a = actionRoles4a; 204 if (isMetafacadePropertyCachingEnabled()) 205 { 206 this.__actionRoles4aSet = true; 207 } 208 } 209 return actionRoles4a; 210 } 211 212 /** 213 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isFormPost() 214 * @return boolean 215 */ 216 protected abstract boolean handleIsFormPost(); 217 218 private boolean __formPost5a; 219 private boolean __formPost5aSet = false; 220 221 /** 222 * Specifies whether or not this action is represented by the posting of a form. 223 * @return (boolean)handleIsFormPost() 224 */ 225 public final boolean isFormPost() 226 { 227 boolean formPost5a = this.__formPost5a; 228 if (!this.__formPost5aSet) 229 { 230 // formPost has no pre constraints 231 formPost5a = handleIsFormPost(); 232 // formPost has no post constraints 233 this.__formPost5a = formPost5a; 234 if (isMetafacadePropertyCachingEnabled()) 235 { 236 this.__formPost5aSet = true; 237 } 238 } 239 return formPost5a; 240 } 241 242 /** 243 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isHyperlink() 244 * @return boolean 245 */ 246 protected abstract boolean handleIsHyperlink(); 247 248 private boolean __hyperlink6a; 249 private boolean __hyperlink6aSet = false; 250 251 /** 252 * Specifies whether or not this action is represented by clicking on a hyperlink. 253 * @return (boolean)handleIsHyperlink() 254 */ 255 public final boolean isHyperlink() 256 { 257 boolean hyperlink6a = this.__hyperlink6a; 258 if (!this.__hyperlink6aSet) 259 { 260 // hyperlink has no pre constraints 261 hyperlink6a = handleIsHyperlink(); 262 // hyperlink has no post constraints 263 this.__hyperlink6a = hyperlink6a; 264 if (isMetafacadePropertyCachingEnabled()) 265 { 266 this.__hyperlink6aSet = true; 267 } 268 } 269 return hyperlink6a; 270 } 271 272 /** 273 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getActionClassName() 274 * @return String 275 */ 276 protected abstract String handleGetActionClassName(); 277 278 private String __actionClassName7a; 279 private boolean __actionClassName7aSet = false; 280 281 /** 282 * A good Java class name for this action. The name is constructed from the source page and the 283 * name of the trigger. 284 * @return (String)handleGetActionClassName() 285 */ 286 public final String getActionClassName() 287 { 288 String actionClassName7a = this.__actionClassName7a; 289 if (!this.__actionClassName7aSet) 290 { 291 // actionClassName has no pre constraints 292 actionClassName7a = handleGetActionClassName(); 293 // actionClassName has no post constraints 294 this.__actionClassName7a = actionClassName7a; 295 if (isMetafacadePropertyCachingEnabled()) 296 { 297 this.__actionClassName7aSet = true; 298 } 299 } 300 return actionClassName7a; 301 } 302 303 /** 304 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getFormBeanClassName() 305 * @return String 306 */ 307 protected abstract String handleGetFormBeanClassName(); 308 309 private String __formBeanClassName8a; 310 private boolean __formBeanClassName8aSet = false; 311 312 /** 313 * Returns the class name of the form bean associated to this action. 314 * @return (String)handleGetFormBeanClassName() 315 */ 316 public final String getFormBeanClassName() 317 { 318 String formBeanClassName8a = this.__formBeanClassName8a; 319 if (!this.__formBeanClassName8aSet) 320 { 321 // formBeanClassName has no pre constraints 322 formBeanClassName8a = handleGetFormBeanClassName(); 323 // formBeanClassName has no post constraints 324 this.__formBeanClassName8a = formBeanClassName8a; 325 if (isMetafacadePropertyCachingEnabled()) 326 { 327 this.__formBeanClassName8aSet = true; 328 } 329 } 330 return formBeanClassName8a; 331 } 332 333 /** 334 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getFormBeanName() 335 * @return String 336 */ 337 protected abstract String handleGetFormBeanName(); 338 339 private String __formBeanName9a; 340 private boolean __formBeanName9aSet = false; 341 342 /** 343 * The name of the form bean associated to this action. The name is returned as it should appear 344 * in the Struts deployment descriptor. 345 * @return (String)handleGetFormBeanName() 346 */ 347 public final String getFormBeanName() 348 { 349 String formBeanName9a = this.__formBeanName9a; 350 if (!this.__formBeanName9aSet) 351 { 352 // formBeanName has no pre constraints 353 formBeanName9a = handleGetFormBeanName(); 354 // formBeanName has no post constraints 355 this.__formBeanName9a = formBeanName9a; 356 if (isMetafacadePropertyCachingEnabled()) 357 { 358 this.__formBeanName9aSet = true; 359 } 360 } 361 return formBeanName9a; 362 } 363 364 /** 365 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getFormValidationMethodName() 366 * @return String 367 */ 368 protected abstract String handleGetFormValidationMethodName(); 369 370 private String __formValidationMethodName10a; 371 private boolean __formValidationMethodName10aSet = false; 372 373 /** 374 * The Javascript function name of the validation method that will validate the action 375 * parameters. 376 * @return (String)handleGetFormValidationMethodName() 377 */ 378 public final String getFormValidationMethodName() 379 { 380 String formValidationMethodName10a = this.__formValidationMethodName10a; 381 if (!this.__formValidationMethodName10aSet) 382 { 383 // formValidationMethodName has no pre constraints 384 formValidationMethodName10a = handleGetFormValidationMethodName(); 385 // formValidationMethodName has no post constraints 386 this.__formValidationMethodName10a = formValidationMethodName10a; 387 if (isMetafacadePropertyCachingEnabled()) 388 { 389 this.__formValidationMethodName10aSet = true; 390 } 391 } 392 return formValidationMethodName10a; 393 } 394 395 /** 396 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isResettable() 397 * @return boolean 398 */ 399 protected abstract boolean handleIsResettable(); 400 401 private boolean __resettable11a; 402 private boolean __resettable11aSet = false; 403 404 /** 405 * True if it should be possible to reset the form represented by this action. False otherwise. 406 * @return (boolean)handleIsResettable() 407 */ 408 public final boolean isResettable() 409 { 410 boolean resettable11a = this.__resettable11a; 411 if (!this.__resettable11aSet) 412 { 413 // resettable has no pre constraints 414 resettable11a = handleIsResettable(); 415 // resettable has no post constraints 416 this.__resettable11a = resettable11a; 417 if (isMetafacadePropertyCachingEnabled()) 418 { 419 this.__resettable11aSet = true; 420 } 421 } 422 return resettable11a; 423 } 424 425 /** 426 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isUseCaseStart() 427 * @return boolean 428 */ 429 protected abstract boolean handleIsUseCaseStart(); 430 431 private boolean __useCaseStart12a; 432 private boolean __useCaseStart12aSet = false; 433 434 /** 435 * True if this action starts the use-case. False otherwise. 436 * @return (boolean)handleIsUseCaseStart() 437 */ 438 public final boolean isUseCaseStart() 439 { 440 boolean useCaseStart12a = this.__useCaseStart12a; 441 if (!this.__useCaseStart12aSet) 442 { 443 // useCaseStart has no pre constraints 444 useCaseStart12a = handleIsUseCaseStart(); 445 // useCaseStart has no post constraints 446 this.__useCaseStart12a = useCaseStart12a; 447 if (isMetafacadePropertyCachingEnabled()) 448 { 449 this.__useCaseStart12aSet = true; 450 } 451 } 452 return useCaseStart12a; 453 } 454 455 /** 456 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getFullActionPath() 457 * @return String 458 */ 459 protected abstract String handleGetFullActionPath(); 460 461 private String __fullActionPath13a; 462 private boolean __fullActionPath13aSet = false; 463 464 /** 465 * The full path for this action. The full path also contains the package name rendered as 466 * directories. 467 * @return (String)handleGetFullActionPath() 468 */ 469 public final String getFullActionPath() 470 { 471 String fullActionPath13a = this.__fullActionPath13a; 472 if (!this.__fullActionPath13aSet) 473 { 474 // fullActionPath has no pre constraints 475 fullActionPath13a = handleGetFullActionPath(); 476 // fullActionPath has no post constraints 477 this.__fullActionPath13a = fullActionPath13a; 478 if (isMetafacadePropertyCachingEnabled()) 479 { 480 this.__fullActionPath13aSet = true; 481 } 482 } 483 return fullActionPath13a; 484 } 485 486 /** 487 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getFullFormBeanPath() 488 * @return String 489 */ 490 protected abstract String handleGetFullFormBeanPath(); 491 492 private String __fullFormBeanPath14a; 493 private boolean __fullFormBeanPath14aSet = false; 494 495 /** 496 * Returns the full path for the form bean associated to this action. 497 * @return (String)handleGetFullFormBeanPath() 498 */ 499 public final String getFullFormBeanPath() 500 { 501 String fullFormBeanPath14a = this.__fullFormBeanPath14a; 502 if (!this.__fullFormBeanPath14aSet) 503 { 504 // fullFormBeanPath has no pre constraints 505 fullFormBeanPath14a = handleGetFullFormBeanPath(); 506 // fullFormBeanPath has no post constraints 507 this.__fullFormBeanPath14a = fullFormBeanPath14a; 508 if (isMetafacadePropertyCachingEnabled()) 509 { 510 this.__fullFormBeanPath14aSet = true; 511 } 512 } 513 return fullFormBeanPath14a; 514 } 515 516 /** 517 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getActionPathRoot() 518 * @return String 519 */ 520 protected abstract String handleGetActionPathRoot(); 521 522 private String __actionPathRoot15a; 523 private boolean __actionPathRoot15aSet = false; 524 525 /** 526 * The root of the action path, this is the same as the path for the use-case context for this 527 * action, that is, the use-case holding the activity graph in which this action is contained. 528 * @return (String)handleGetActionPathRoot() 529 */ 530 public final String getActionPathRoot() 531 { 532 String actionPathRoot15a = this.__actionPathRoot15a; 533 if (!this.__actionPathRoot15aSet) 534 { 535 // actionPathRoot has no pre constraints 536 actionPathRoot15a = handleGetActionPathRoot(); 537 // actionPathRoot has no post constraints 538 this.__actionPathRoot15a = actionPathRoot15a; 539 if (isMetafacadePropertyCachingEnabled()) 540 { 541 this.__actionPathRoot15aSet = true; 542 } 543 } 544 return actionPathRoot15a; 545 } 546 547 /** 548 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isValidationRequired() 549 * @return boolean 550 */ 551 protected abstract boolean handleIsValidationRequired(); 552 553 private boolean __validationRequired16a; 554 private boolean __validationRequired16aSet = false; 555 556 /** 557 * True if this action requires validation, false otherwise. An action requires validation if it 558 * represented by a form and one or more fields require validation. 559 * @return (boolean)handleIsValidationRequired() 560 */ 561 public final boolean isValidationRequired() 562 { 563 boolean validationRequired16a = this.__validationRequired16a; 564 if (!this.__validationRequired16aSet) 565 { 566 // validationRequired has no pre constraints 567 validationRequired16a = handleIsValidationRequired(); 568 // validationRequired has no post constraints 569 this.__validationRequired16a = validationRequired16a; 570 if (isMetafacadePropertyCachingEnabled()) 571 { 572 this.__validationRequired16aSet = true; 573 } 574 } 575 return validationRequired16a; 576 } 577 578 /** 579 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getFormBeanType() 580 * @return String 581 */ 582 protected abstract String handleGetFormBeanType(); 583 584 private String __formBeanType17a; 585 private boolean __formBeanType17aSet = false; 586 587 /** 588 * The fully qualified name of the form bean associated to this action. 589 * @return (String)handleGetFormBeanType() 590 */ 591 public final String getFormBeanType() 592 { 593 String formBeanType17a = this.__formBeanType17a; 594 if (!this.__formBeanType17aSet) 595 { 596 // formBeanType has no pre constraints 597 formBeanType17a = handleGetFormBeanType(); 598 // formBeanType has no post constraints 599 this.__formBeanType17a = formBeanType17a; 600 if (isMetafacadePropertyCachingEnabled()) 601 { 602 this.__formBeanType17aSet = true; 603 } 604 } 605 return formBeanType17a; 606 } 607 608 /** 609 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getDocumentationValue() 610 * @return String 611 */ 612 protected abstract String handleGetDocumentationValue(); 613 614 private String __documentationValue18a; 615 private boolean __documentationValue18aSet = false; 616 617 /** 618 * The documentation for this action as a String that can be used as a resource message (with 619 * the backslashes at the end of the line). 620 * @return (String)handleGetDocumentationValue() 621 */ 622 public final String getDocumentationValue() 623 { 624 String documentationValue18a = this.__documentationValue18a; 625 if (!this.__documentationValue18aSet) 626 { 627 // documentationValue has no pre constraints 628 documentationValue18a = handleGetDocumentationValue(); 629 // documentationValue has no post constraints 630 this.__documentationValue18a = documentationValue18a; 631 if (isMetafacadePropertyCachingEnabled()) 632 { 633 this.__documentationValue18aSet = true; 634 } 635 } 636 return documentationValue18a; 637 } 638 639 /** 640 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getDocumentationKey() 641 * @return String 642 */ 643 protected abstract String handleGetDocumentationKey(); 644 645 private String __documentationKey19a; 646 private boolean __documentationKey19aSet = false; 647 648 /** 649 * A key suited as a resource message key for the documentation for this action. 650 * @return (String)handleGetDocumentationKey() 651 */ 652 public final String getDocumentationKey() 653 { 654 String documentationKey19a = this.__documentationKey19a; 655 if (!this.__documentationKey19aSet) 656 { 657 // documentationKey has no pre constraints 658 documentationKey19a = handleGetDocumentationKey(); 659 // documentationKey has no post constraints 660 this.__documentationKey19a = documentationKey19a; 661 if (isMetafacadePropertyCachingEnabled()) 662 { 663 this.__documentationKey19aSet = true; 664 } 665 } 666 return documentationKey19a; 667 } 668 669 /** 670 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getFullTilePath() 671 * @return String 672 */ 673 protected abstract String handleGetFullTilePath(); 674 675 private String __fullTilePath20a; 676 private boolean __fullTilePath20aSet = false; 677 678 /** 679 * The name of a file that can be used as a JSP file name in case you want to have each action 680 * rendered onto a different tile. 681 * @return (String)handleGetFullTilePath() 682 */ 683 public final String getFullTilePath() 684 { 685 String fullTilePath20a = this.__fullTilePath20a; 686 if (!this.__fullTilePath20aSet) 687 { 688 // fullTilePath has no pre constraints 689 fullTilePath20a = handleGetFullTilePath(); 690 // fullTilePath has no post constraints 691 this.__fullTilePath20a = fullTilePath20a; 692 if (isMetafacadePropertyCachingEnabled()) 693 { 694 this.__fullTilePath20aSet = true; 695 } 696 } 697 return fullTilePath20a; 698 } 699 700 /** 701 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isDateFieldPresent() 702 * @return boolean 703 */ 704 protected abstract boolean handleIsDateFieldPresent(); 705 706 private boolean __dateFieldPresent21a; 707 private boolean __dateFieldPresent21aSet = false; 708 709 /** 710 * True if this action contains a parameter of type Date. The generated pages will contain 711 * special javascript code to handle them (popup window etc...). 712 * @return (boolean)handleIsDateFieldPresent() 713 */ 714 public final boolean isDateFieldPresent() 715 { 716 boolean dateFieldPresent21a = this.__dateFieldPresent21a; 717 if (!this.__dateFieldPresent21aSet) 718 { 719 // dateFieldPresent has no pre constraints 720 dateFieldPresent21a = handleIsDateFieldPresent(); 721 // dateFieldPresent has no post constraints 722 this.__dateFieldPresent21a = dateFieldPresent21a; 723 if (isMetafacadePropertyCachingEnabled()) 724 { 725 this.__dateFieldPresent21aSet = true; 726 } 727 } 728 return dateFieldPresent21a; 729 } 730 731 /** 732 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isCalendarRequired() 733 * @return boolean 734 */ 735 protected abstract boolean handleIsCalendarRequired(); 736 737 private boolean __calendarRequired22a; 738 private boolean __calendarRequired22aSet = false; 739 740 /** 741 * True if this action contains a parameter which requires a calendar popup. 742 * @return (boolean)handleIsCalendarRequired() 743 */ 744 public final boolean isCalendarRequired() 745 { 746 boolean calendarRequired22a = this.__calendarRequired22a; 747 if (!this.__calendarRequired22aSet) 748 { 749 // calendarRequired has no pre constraints 750 calendarRequired22a = handleIsCalendarRequired(); 751 // calendarRequired has no post constraints 752 this.__calendarRequired22a = calendarRequired22a; 753 if (isMetafacadePropertyCachingEnabled()) 754 { 755 this.__calendarRequired22aSet = true; 756 } 757 } 758 return calendarRequired22a; 759 } 760 761 /** 762 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isTableLink() 763 * @return boolean 764 */ 765 protected abstract boolean handleIsTableLink(); 766 767 private boolean __tableLink23a; 768 private boolean __tableLink23aSet = false; 769 770 /** 771 * True if a table link name has been specified and it properly targets a table page-variable 772 * from the input page. 773 * @return (boolean)handleIsTableLink() 774 */ 775 public final boolean isTableLink() 776 { 777 boolean tableLink23a = this.__tableLink23a; 778 if (!this.__tableLink23aSet) 779 { 780 // tableLink has no pre constraints 781 tableLink23a = handleIsTableLink(); 782 // tableLink has no post constraints 783 this.__tableLink23a = tableLink23a; 784 if (isMetafacadePropertyCachingEnabled()) 785 { 786 this.__tableLink23aSet = true; 787 } 788 } 789 return tableLink23a; 790 } 791 792 /** 793 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getOnlineHelpKey() 794 * @return String 795 */ 796 protected abstract String handleGetOnlineHelpKey(); 797 798 private String __onlineHelpKey24a; 799 private boolean __onlineHelpKey24aSet = false; 800 801 /** 802 * The key to lookup the online help documentation. This documentation is gathered from the 803 * documentation entered by the user, as well as analyzing the model. 804 * @return (String)handleGetOnlineHelpKey() 805 */ 806 public final String getOnlineHelpKey() 807 { 808 String onlineHelpKey24a = this.__onlineHelpKey24a; 809 if (!this.__onlineHelpKey24aSet) 810 { 811 // onlineHelpKey has no pre constraints 812 onlineHelpKey24a = handleGetOnlineHelpKey(); 813 // onlineHelpKey has no post constraints 814 this.__onlineHelpKey24a = onlineHelpKey24a; 815 if (isMetafacadePropertyCachingEnabled()) 816 { 817 this.__onlineHelpKey24aSet = true; 818 } 819 } 820 return onlineHelpKey24a; 821 } 822 823 /** 824 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getOnlineHelpValue() 825 * @return String 826 */ 827 protected abstract String handleGetOnlineHelpValue(); 828 829 private String __onlineHelpValue25a; 830 private boolean __onlineHelpValue25aSet = false; 831 832 /** 833 * The online help documentation. This documentation is gathered from the documentation entered 834 * by the user, as well as analyzing the model. The format is HTML without any style. 835 * @return (String)handleGetOnlineHelpValue() 836 */ 837 public final String getOnlineHelpValue() 838 { 839 String onlineHelpValue25a = this.__onlineHelpValue25a; 840 if (!this.__onlineHelpValue25aSet) 841 { 842 // onlineHelpValue has no pre constraints 843 onlineHelpValue25a = handleGetOnlineHelpValue(); 844 // onlineHelpValue has no post constraints 845 this.__onlineHelpValue25a = onlineHelpValue25a; 846 if (isMetafacadePropertyCachingEnabled()) 847 { 848 this.__onlineHelpValue25aSet = true; 849 } 850 } 851 return onlineHelpValue25a; 852 } 853 854 /** 855 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getActionScope() 856 * @return String 857 */ 858 protected abstract String handleGetActionScope(); 859 860 private String __actionScope26a; 861 private boolean __actionScope26aSet = false; 862 863 /** 864 * The scope in which the form bean will be placed (could be page, request, session or 865 * application). 866 * @return (String)handleGetActionScope() 867 */ 868 public final String getActionScope() 869 { 870 String actionScope26a = this.__actionScope26a; 871 if (!this.__actionScope26aSet) 872 { 873 // actionScope has no pre constraints 874 actionScope26a = handleGetActionScope(); 875 // actionScope has no post constraints 876 this.__actionScope26a = actionScope26a; 877 if (isMetafacadePropertyCachingEnabled()) 878 { 879 this.__actionScope26aSet = true; 880 } 881 } 882 return actionScope26a; 883 } 884 885 /** 886 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getFormBeanPackageName() 887 * @return String 888 */ 889 protected abstract String handleGetFormBeanPackageName(); 890 891 private String __formBeanPackageName27a; 892 private boolean __formBeanPackageName27aSet = false; 893 894 /** 895 * The package for the form bean. 896 * @return (String)handleGetFormBeanPackageName() 897 */ 898 public final String getFormBeanPackageName() 899 { 900 String formBeanPackageName27a = this.__formBeanPackageName27a; 901 if (!this.__formBeanPackageName27aSet) 902 { 903 // formBeanPackageName has no pre constraints 904 formBeanPackageName27a = handleGetFormBeanPackageName(); 905 // formBeanPackageName has no post constraints 906 this.__formBeanPackageName27a = formBeanPackageName27a; 907 if (isMetafacadePropertyCachingEnabled()) 908 { 909 this.__formBeanPackageName27aSet = true; 910 } 911 } 912 return formBeanPackageName27a; 913 } 914 915 /** 916 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getActionType() 917 * @return String 918 */ 919 protected abstract String handleGetActionType(); 920 921 private String __actionType28a; 922 private boolean __actionType28aSet = false; 923 924 /** 925 * The fully qualified name for the action class. 926 * @return (String)handleGetActionType() 927 */ 928 public final String getActionType() 929 { 930 String actionType28a = this.__actionType28a; 931 if (!this.__actionType28aSet) 932 { 933 // actionType has no pre constraints 934 actionType28a = handleGetActionType(); 935 // actionType has no post constraints 936 this.__actionType28a = actionType28a; 937 if (isMetafacadePropertyCachingEnabled()) 938 { 939 this.__actionType28aSet = true; 940 } 941 } 942 return actionType28a; 943 } 944 945 /** 946 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getStyleId() 947 * @return String 948 */ 949 protected abstract String handleGetStyleId(); 950 951 private String __styleId29a; 952 private boolean __styleId29aSet = false; 953 954 /** 955 * The name of the CSS id in which this action will be contained. 956 * @return (String)handleGetStyleId() 957 */ 958 public final String getStyleId() 959 { 960 String styleId29a = this.__styleId29a; 961 if (!this.__styleId29aSet) 962 { 963 // styleId has no pre constraints 964 styleId29a = handleGetStyleId(); 965 // styleId has no post constraints 966 this.__styleId29a = styleId29a; 967 if (isMetafacadePropertyCachingEnabled()) 968 { 969 this.__styleId29aSet = true; 970 } 971 } 972 return styleId29a; 973 } 974 975 /** 976 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isRedirect() 977 * @return boolean 978 */ 979 protected abstract boolean handleIsRedirect(); 980 981 private boolean __redirect30a; 982 private boolean __redirect30aSet = false; 983 984 /** 985 * Defines whether or not when this action's forward is executed, an HTTP redirect should occur. 986 * Default value is based on the value of the 'defaultActionRedirect' namespace. 987 * @return (boolean)handleIsRedirect() 988 */ 989 public final boolean isRedirect() 990 { 991 boolean redirect30a = this.__redirect30a; 992 if (!this.__redirect30aSet) 993 { 994 // redirect has no pre constraints 995 redirect30a = handleIsRedirect(); 996 // redirect has no post constraints 997 this.__redirect30a = redirect30a; 998 if (isMetafacadePropertyCachingEnabled()) 999 { 1000 this.__redirect30aSet = true; 1001 } 1002 } 1003 return redirect30a; 1004 } 1005 1006 /** 1007 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getFormScope() 1008 * @return String 1009 */ 1010 protected abstract String handleGetFormScope(); 1011 1012 private String __formScope31a; 1013 private boolean __formScope31aSet = false; 1014 1015 /** 1016 * The scope to place the current "form" variable within when this action is executing. 1017 * @return (String)handleGetFormScope() 1018 */ 1019 public final String getFormScope() 1020 { 1021 String formScope31a = this.__formScope31a; 1022 if (!this.__formScope31aSet) 1023 { 1024 // formScope has no pre constraints 1025 formScope31a = handleGetFormScope(); 1026 // formScope has no post constraints 1027 this.__formScope31a = formScope31a; 1028 if (isMetafacadePropertyCachingEnabled()) 1029 { 1030 this.__formScope31aSet = true; 1031 } 1032 } 1033 return formScope31a; 1034 } 1035 1036 /** 1037 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isFormScopeSession() 1038 * @return boolean 1039 */ 1040 protected abstract boolean handleIsFormScopeSession(); 1041 1042 private boolean __formScopeSession32a; 1043 private boolean __formScopeSession32aSet = false; 1044 1045 /** 1046 * Indicates if the form scope is of type "session". 1047 * @return (boolean)handleIsFormScopeSession() 1048 */ 1049 public final boolean isFormScopeSession() 1050 { 1051 boolean formScopeSession32a = this.__formScopeSession32a; 1052 if (!this.__formScopeSession32aSet) 1053 { 1054 // formScopeSession has no pre constraints 1055 formScopeSession32a = handleIsFormScopeSession(); 1056 // formScopeSession has no post constraints 1057 this.__formScopeSession32a = formScopeSession32a; 1058 if (isMetafacadePropertyCachingEnabled()) 1059 { 1060 this.__formScopeSession32aSet = true; 1061 } 1062 } 1063 return formScopeSession32a; 1064 } 1065 1066 /** 1067 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isFormScopeRequest() 1068 * @return boolean 1069 */ 1070 protected abstract boolean handleIsFormScopeRequest(); 1071 1072 private boolean __formScopeRequest33a; 1073 private boolean __formScopeRequest33aSet = false; 1074 1075 /** 1076 * Indicates if the from scope is of type "request". 1077 * @return (boolean)handleIsFormScopeRequest() 1078 */ 1079 public final boolean isFormScopeRequest() 1080 { 1081 boolean formScopeRequest33a = this.__formScopeRequest33a; 1082 if (!this.__formScopeRequest33aSet) 1083 { 1084 // formScopeRequest has no pre constraints 1085 formScopeRequest33a = handleIsFormScopeRequest(); 1086 // formScopeRequest has no post constraints 1087 this.__formScopeRequest33a = formScopeRequest33a; 1088 if (isMetafacadePropertyCachingEnabled()) 1089 { 1090 this.__formScopeRequest33aSet = true; 1091 } 1092 } 1093 return formScopeRequest33a; 1094 } 1095 1096 /** 1097 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isFormScopeNone() 1098 * @return boolean 1099 */ 1100 protected abstract boolean handleIsFormScopeNone(); 1101 1102 private boolean __formScopeNone34a; 1103 private boolean __formScopeNone34aSet = false; 1104 1105 /** 1106 * Indicates if the form scope is of type "none". 1107 * @return (boolean)handleIsFormScopeNone() 1108 */ 1109 public final boolean isFormScopeNone() 1110 { 1111 boolean formScopeNone34a = this.__formScopeNone34a; 1112 if (!this.__formScopeNone34aSet) 1113 { 1114 // formScopeNone has no pre constraints 1115 formScopeNone34a = handleIsFormScopeNone(); 1116 // formScopeNone has no post constraints 1117 this.__formScopeNone34a = formScopeNone34a; 1118 if (isMetafacadePropertyCachingEnabled()) 1119 { 1120 this.__formScopeNone34aSet = true; 1121 } 1122 } 1123 return formScopeNone34a; 1124 } 1125 1126 /** 1127 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getTableLinkName() 1128 * @return String 1129 */ 1130 protected abstract String handleGetTableLinkName(); 1131 1132 private String __tableLinkName35a; 1133 private boolean __tableLinkName35aSet = false; 1134 1135 /** 1136 * The name of the table link specified for this action. 1137 * @return (String)handleGetTableLinkName() 1138 */ 1139 public final String getTableLinkName() 1140 { 1141 String tableLinkName35a = this.__tableLinkName35a; 1142 if (!this.__tableLinkName35aSet) 1143 { 1144 // tableLinkName has no pre constraints 1145 tableLinkName35a = handleGetTableLinkName(); 1146 // tableLinkName has no post constraints 1147 this.__tableLinkName35a = tableLinkName35a; 1148 if (isMetafacadePropertyCachingEnabled()) 1149 { 1150 this.__tableLinkName35aSet = true; 1151 } 1152 } 1153 return tableLinkName35a; 1154 } 1155 1156 /** 1157 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getTableLinkColumnName() 1158 * @return String 1159 */ 1160 protected abstract String handleGetTableLinkColumnName(); 1161 1162 private String __tableLinkColumnName36a; 1163 private boolean __tableLinkColumnName36aSet = false; 1164 1165 /** 1166 * The name of the column targetted by this action. 1167 * @return (String)handleGetTableLinkColumnName() 1168 */ 1169 public final String getTableLinkColumnName() 1170 { 1171 String tableLinkColumnName36a = this.__tableLinkColumnName36a; 1172 if (!this.__tableLinkColumnName36aSet) 1173 { 1174 // tableLinkColumnName has no pre constraints 1175 tableLinkColumnName36a = handleGetTableLinkColumnName(); 1176 // tableLinkColumnName has no post constraints 1177 this.__tableLinkColumnName36a = tableLinkColumnName36a; 1178 if (isMetafacadePropertyCachingEnabled()) 1179 { 1180 this.__tableLinkColumnName36aSet = true; 1181 } 1182 } 1183 return tableLinkColumnName36a; 1184 } 1185 1186 /** 1187 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isImageLink() 1188 * @return boolean 1189 */ 1190 protected abstract boolean handleIsImageLink(); 1191 1192 private boolean __imageLink37a; 1193 private boolean __imageLink37aSet = false; 1194 1195 /** 1196 * Specifies whether or not this action is represented by clicking on an image. 1197 * @return (boolean)handleIsImageLink() 1198 */ 1199 public final boolean isImageLink() 1200 { 1201 boolean imageLink37a = this.__imageLink37a; 1202 if (!this.__imageLink37aSet) 1203 { 1204 // imageLink has no pre constraints 1205 imageLink37a = handleIsImageLink(); 1206 // imageLink has no post constraints 1207 this.__imageLink37a = imageLink37a; 1208 if (isMetafacadePropertyCachingEnabled()) 1209 { 1210 this.__imageLink37aSet = true; 1211 } 1212 } 1213 return imageLink37a; 1214 } 1215 1216 /** 1217 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getImagePath() 1218 * @return String 1219 */ 1220 protected abstract String handleGetImagePath(); 1221 1222 private String __imagePath38a; 1223 private boolean __imagePath38aSet = false; 1224 1225 /** 1226 * If this action is an imageLink this property represents the path to the corresponding image. 1227 * @return (String)handleGetImagePath() 1228 */ 1229 public final String getImagePath() 1230 { 1231 String imagePath38a = this.__imagePath38a; 1232 if (!this.__imagePath38aSet) 1233 { 1234 // imagePath has no pre constraints 1235 imagePath38a = handleGetImagePath(); 1236 // imagePath has no post constraints 1237 this.__imagePath38a = imagePath38a; 1238 if (isMetafacadePropertyCachingEnabled()) 1239 { 1240 this.__imagePath38aSet = true; 1241 } 1242 } 1243 return imagePath38a; 1244 } 1245 1246 /** 1247 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getMessageKey() 1248 * @return String 1249 */ 1250 protected abstract String handleGetMessageKey(); 1251 1252 private String __messageKey39a; 1253 private boolean __messageKey39aSet = false; 1254 1255 /** 1256 * TODO: Model Documentation for 1257 * org.andromda.cartridges.bpm4struts.metafacades.StrutsAction.messageKey 1258 * @return (String)handleGetMessageKey() 1259 */ 1260 public final String getMessageKey() 1261 { 1262 String messageKey39a = this.__messageKey39a; 1263 if (!this.__messageKey39aSet) 1264 { 1265 // messageKey has no pre constraints 1266 messageKey39a = handleGetMessageKey(); 1267 // messageKey has no post constraints 1268 this.__messageKey39a = messageKey39a; 1269 if (isMetafacadePropertyCachingEnabled()) 1270 { 1271 this.__messageKey39aSet = true; 1272 } 1273 } 1274 return messageKey39a; 1275 } 1276 1277 /** 1278 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#getImageMessageKey() 1279 * @return String 1280 */ 1281 protected abstract String handleGetImageMessageKey(); 1282 1283 private String __imageMessageKey40a; 1284 private boolean __imageMessageKey40aSet = false; 1285 1286 /** 1287 * The resource message key used to look to location of the image for this action. 1288 * @return (String)handleGetImageMessageKey() 1289 */ 1290 public final String getImageMessageKey() 1291 { 1292 String imageMessageKey40a = this.__imageMessageKey40a; 1293 if (!this.__imageMessageKey40aSet) 1294 { 1295 // imageMessageKey has no pre constraints 1296 imageMessageKey40a = handleGetImageMessageKey(); 1297 // imageMessageKey has no post constraints 1298 this.__imageMessageKey40a = imageMessageKey40a; 1299 if (isMetafacadePropertyCachingEnabled()) 1300 { 1301 this.__imageMessageKey40aSet = true; 1302 } 1303 } 1304 return imageMessageKey40a; 1305 } 1306 1307 /** 1308 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isTableAction() 1309 * @return boolean 1310 */ 1311 protected abstract boolean handleIsTableAction(); 1312 1313 private boolean __tableAction41a; 1314 private boolean __tableAction41aSet = false; 1315 1316 /** 1317 * Denotes this action works on all rows of the table from the table link relation. 1318 * @return (boolean)handleIsTableAction() 1319 */ 1320 public final boolean isTableAction() 1321 { 1322 boolean tableAction41a = this.__tableAction41a; 1323 if (!this.__tableAction41aSet) 1324 { 1325 // tableAction has no pre constraints 1326 tableAction41a = handleIsTableAction(); 1327 // tableAction has no post constraints 1328 this.__tableAction41a = tableAction41a; 1329 if (isMetafacadePropertyCachingEnabled()) 1330 { 1331 this.__tableAction41aSet = true; 1332 } 1333 } 1334 return tableAction41a; 1335 } 1336 1337 /** 1338 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isTableRowAction() 1339 * @return boolean 1340 */ 1341 protected abstract boolean handleIsTableRowAction(); 1342 1343 private boolean __tableRowAction42a; 1344 private boolean __tableRowAction42aSet = false; 1345 1346 /** 1347 * Denotes this action works on a single row of the table from the table link relation. 1348 * @return (boolean)handleIsTableRowAction() 1349 */ 1350 public final boolean isTableRowAction() 1351 { 1352 boolean tableRowAction42a = this.__tableRowAction42a; 1353 if (!this.__tableRowAction42aSet) 1354 { 1355 // tableRowAction has no pre constraints 1356 tableRowAction42a = handleIsTableRowAction(); 1357 // tableRowAction has no post constraints 1358 this.__tableRowAction42a = tableRowAction42a; 1359 if (isMetafacadePropertyCachingEnabled()) 1360 { 1361 this.__tableRowAction42aSet = true; 1362 } 1363 } 1364 return tableRowAction42a; 1365 } 1366 1367 /** 1368 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAction#isMultipartFormData() 1369 * @return boolean 1370 */ 1371 protected abstract boolean handleIsMultipartFormData(); 1372 1373 private boolean __multipartFormData43a; 1374 private boolean __multipartFormData43aSet = false; 1375 1376 /** 1377 * True is this action is supposed to be rendered as enctype="multipart/form-data" on the page 1378 * form. 1379 * @return (boolean)handleIsMultipartFormData() 1380 */ 1381 public final boolean isMultipartFormData() 1382 { 1383 boolean multipartFormData43a = this.__multipartFormData43a; 1384 if (!this.__multipartFormData43aSet) 1385 { 1386 // multipartFormData has no pre constraints 1387 multipartFormData43a = handleIsMultipartFormData(); 1388 // multipartFormData has no post constraints 1389 this.__multipartFormData43a = multipartFormData43a; 1390 if (isMetafacadePropertyCachingEnabled()) 1391 { 1392 this.__multipartFormData43aSet = true; 1393 } 1394 } 1395 return multipartFormData43a; 1396 } 1397 1398 // ---------------- business methods ---------------------- 1399 1400 /** 1401 * Method to be implemented in descendants 1402 * Those parameters that are directly entering a final state and have been submitted into the 1403 * request, they will be able to survive a trip to the next use-case. All returned elements are 1404 * of type StrutsParameter. 1405 * @param finalState 1406 * @return List 1407 */ 1408 protected abstract List handleGetInterUseCaseParameters(StrutsFinalState finalState); 1409 1410 /** 1411 * Those parameters that are directly entering a final state and have been submitted into the 1412 * request, they will be able to survive a trip to the next use-case. All returned elements are 1413 * of type StrutsParameter. 1414 * @param finalState StrutsFinalState 1415 * TODO: Model Documentation for 1416 * org.andromda.cartridges.bpm4struts.metafacades.StrutsAction.getInterUseCaseParameters(finalState) 1417 * @return handleGetInterUseCaseParameters(finalState) 1418 */ 1419 public List getInterUseCaseParameters(StrutsFinalState finalState) 1420 { 1421 // getInterUseCaseParameters has no pre constraints 1422 List returnValue = handleGetInterUseCaseParameters(finalState); 1423 // getInterUseCaseParameters has no post constraints 1424 return returnValue; 1425 } 1426 1427 // ------------- associations ------------------ 1428 1429 private List<StrutsParameter> __getResettableActionParameters1r; 1430 private boolean __getResettableActionParameters1rSet = false; 1431 1432 /** 1433 * Represents a Struts action. Such an action typically is associated with a form bean. 1434 * This action model element extends a transition, but the actual logic contained by the action 1435 * envelops all action states called, until either a final state or JSP page is reached. 1436 * @return (List<StrutsParameter>)handleGetResettableActionParameters() 1437 */ 1438 public final List<StrutsParameter> getResettableActionParameters() 1439 { 1440 List<StrutsParameter> getResettableActionParameters1r = this.__getResettableActionParameters1r; 1441 if (!this.__getResettableActionParameters1rSet) 1442 { 1443 // strutsAction has no pre constraints 1444 List result = handleGetResettableActionParameters(); 1445 List shieldedResult = this.shieldedElements(result); 1446 try 1447 { 1448 getResettableActionParameters1r = (List<StrutsParameter>)shieldedResult; 1449 } 1450 catch (ClassCastException ex) 1451 { 1452 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1453 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getResettableActionParameters List<StrutsParameter> " + result + ": " + shieldedResult); 1454 } 1455 // strutsAction has no post constraints 1456 this.__getResettableActionParameters1r = getResettableActionParameters1r; 1457 if (isMetafacadePropertyCachingEnabled()) 1458 { 1459 this.__getResettableActionParameters1rSet = true; 1460 } 1461 } 1462 return getResettableActionParameters1r; 1463 } 1464 1465 /** 1466 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type 1467 * @return List 1468 */ 1469 protected abstract List handleGetResettableActionParameters(); 1470 1471 private StrutsJsp __getInput2r; 1472 private boolean __getInput2rSet = false; 1473 1474 /** 1475 * Represents a Struts action. Such an action typically is associated with a form bean. 1476 * This action model element extends a transition, but the actual logic contained by the action 1477 * envelops all action states called, until either a final state or JSP page is reached. 1478 * @return (StrutsJsp)handleGetInput() 1479 */ 1480 public final StrutsJsp getInput() 1481 { 1482 StrutsJsp getInput2r = this.__getInput2r; 1483 if (!this.__getInput2rSet) 1484 { 1485 // strutsAction has no pre constraints 1486 Object result = handleGetInput(); 1487 MetafacadeBase shieldedResult = this.shieldedElement(result); 1488 try 1489 { 1490 getInput2r = (StrutsJsp)shieldedResult; 1491 } 1492 catch (ClassCastException ex) 1493 { 1494 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1495 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getInput StrutsJsp " + result + ": " + shieldedResult); 1496 } 1497 // strutsAction has no post constraints 1498 this.__getInput2r = getInput2r; 1499 if (isMetafacadePropertyCachingEnabled()) 1500 { 1501 this.__getInput2rSet = true; 1502 } 1503 } 1504 return getInput2r; 1505 } 1506 1507 /** 1508 * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type 1509 * @return Object 1510 */ 1511 protected abstract Object handleGetInput(); 1512 1513 private List<StrutsJsp> __getTargetPages3r; 1514 private boolean __getTargetPages3rSet = false; 1515 1516 /** 1517 * Returns all actions that possibly result in returning this page. 1518 * @return (List<StrutsJsp>)handleGetTargetPages() 1519 */ 1520 public final List<StrutsJsp> getTargetPages() 1521 { 1522 List<StrutsJsp> getTargetPages3r = this.__getTargetPages3r; 1523 if (!this.__getTargetPages3rSet) 1524 { 1525 // incomingActions has no pre constraints 1526 List result = handleGetTargetPages(); 1527 List shieldedResult = this.shieldedElements(result); 1528 try 1529 { 1530 getTargetPages3r = (List<StrutsJsp>)shieldedResult; 1531 } 1532 catch (ClassCastException ex) 1533 { 1534 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1535 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getTargetPages List<StrutsJsp> " + result + ": " + shieldedResult); 1536 } 1537 // incomingActions has no post constraints 1538 this.__getTargetPages3r = getTargetPages3r; 1539 if (isMetafacadePropertyCachingEnabled()) 1540 { 1541 this.__getTargetPages3rSet = true; 1542 } 1543 } 1544 return getTargetPages3r; 1545 } 1546 1547 /** 1548 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type 1549 * @return List 1550 */ 1551 protected abstract List handleGetTargetPages(); 1552 1553 private List<StrutsExceptionHandler> __getActionExceptions4r; 1554 private boolean __getActionExceptions4rSet = false; 1555 1556 /** 1557 * Represents a Struts action. Such an action typically is associated with a form bean. 1558 * This action model element extends a transition, but the actual logic contained by the action 1559 * envelops all action states called, until either a final state or JSP page is reached. 1560 * @return (List<StrutsExceptionHandler>)handleGetActionExceptions() 1561 */ 1562 public final List<StrutsExceptionHandler> getActionExceptions() 1563 { 1564 List<StrutsExceptionHandler> getActionExceptions4r = this.__getActionExceptions4r; 1565 if (!this.__getActionExceptions4rSet) 1566 { 1567 // strutsAction has no pre constraints 1568 List result = handleGetActionExceptions(); 1569 List shieldedResult = this.shieldedElements(result); 1570 try 1571 { 1572 getActionExceptions4r = (List<StrutsExceptionHandler>)shieldedResult; 1573 } 1574 catch (ClassCastException ex) 1575 { 1576 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1577 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getActionExceptions List<StrutsExceptionHandler> " + result + ": " + shieldedResult); 1578 } 1579 // strutsAction has no post constraints 1580 this.__getActionExceptions4r = getActionExceptions4r; 1581 if (isMetafacadePropertyCachingEnabled()) 1582 { 1583 this.__getActionExceptions4rSet = true; 1584 } 1585 } 1586 return getActionExceptions4r; 1587 } 1588 1589 /** 1590 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type 1591 * @return List 1592 */ 1593 protected abstract List handleGetActionExceptions(); 1594 1595 /** 1596 * Represents a Struts action. Such an action typically is associated with a form bean. 1597 * This action model element extends a transition, but the actual logic contained by the action 1598 * envelops all action states called, until either a final state or JSP page is reached. 1599 * @return (List<StrutsParameter>)handleGetTableNonColumnFormParameters() 1600 */ 1601 public final List<StrutsParameter> getTableNonColumnFormParameters() 1602 { 1603 List<StrutsParameter> getTableNonColumnFormParameters5r = null; 1604 // strutsAction has no pre constraints 1605 List result = handleGetTableNonColumnFormParameters(); 1606 List shieldedResult = this.shieldedElements(result); 1607 try 1608 { 1609 getTableNonColumnFormParameters5r = (List<StrutsParameter>)shieldedResult; 1610 } 1611 catch (ClassCastException ex) 1612 { 1613 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1614 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getTableNonColumnFormParameters List<StrutsParameter> " + result + ": " + shieldedResult); 1615 } 1616 // strutsAction has no post constraints 1617 return getTableNonColumnFormParameters5r; 1618 } 1619 1620 /** 1621 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type 1622 * @return List 1623 */ 1624 protected abstract List handleGetTableNonColumnFormParameters(); 1625 1626 private List<StrutsParameter> __getActionParameters6r; 1627 private boolean __getActionParameters6rSet = false; 1628 1629 /** 1630 * The actions used when submitting forms for this table. Table actions that are hyperlinks are 1631 * not included. It only makes sense to call this property on parameters that represent a table 1632 * page-variable. 1633 * @return (List<StrutsParameter>)handleGetActionParameters() 1634 */ 1635 public final List<StrutsParameter> getActionParameters() 1636 { 1637 List<StrutsParameter> getActionParameters6r = this.__getActionParameters6r; 1638 if (!this.__getActionParameters6rSet) 1639 { 1640 // tableFormActions has no pre constraints 1641 List result = handleGetActionParameters(); 1642 List shieldedResult = this.shieldedElements(result); 1643 try 1644 { 1645 getActionParameters6r = (List<StrutsParameter>)shieldedResult; 1646 } 1647 catch (ClassCastException ex) 1648 { 1649 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1650 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getActionParameters List<StrutsParameter> " + result + ": " + shieldedResult); 1651 } 1652 // tableFormActions has no post constraints 1653 this.__getActionParameters6r = getActionParameters6r; 1654 if (isMetafacadePropertyCachingEnabled()) 1655 { 1656 this.__getActionParameters6rSet = true; 1657 } 1658 } 1659 return getActionParameters6r; 1660 } 1661 1662 /** 1663 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type 1664 * @return List 1665 */ 1666 protected abstract List handleGetActionParameters(); 1667 1668 private List<StrutsControllerOperation> __getDeferredOperations7r; 1669 private boolean __getDeferredOperations7rSet = false; 1670 1671 /** 1672 * Represents a Struts action. Such an action typically is associated with a form bean. 1673 * This action model element extends a transition, but the actual logic contained by the action 1674 * envelops all action states called, until either a final state or JSP page is reached. 1675 * @return (List<StrutsControllerOperation>)handleGetDeferredOperations() 1676 */ 1677 public final List<StrutsControllerOperation> getDeferredOperations() 1678 { 1679 List<StrutsControllerOperation> getDeferredOperations7r = this.__getDeferredOperations7r; 1680 if (!this.__getDeferredOperations7rSet) 1681 { 1682 // strutsAction has no pre constraints 1683 List result = handleGetDeferredOperations(); 1684 List shieldedResult = this.shieldedElements(result); 1685 try 1686 { 1687 getDeferredOperations7r = (List<StrutsControllerOperation>)shieldedResult; 1688 } 1689 catch (ClassCastException ex) 1690 { 1691 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1692 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getDeferredOperations List<StrutsControllerOperation> " + result + ": " + shieldedResult); 1693 } 1694 // strutsAction has no post constraints 1695 this.__getDeferredOperations7r = getDeferredOperations7r; 1696 if (isMetafacadePropertyCachingEnabled()) 1697 { 1698 this.__getDeferredOperations7rSet = true; 1699 } 1700 } 1701 return getDeferredOperations7r; 1702 } 1703 1704 /** 1705 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type 1706 * @return List 1707 */ 1708 protected abstract List handleGetDeferredOperations(); 1709 1710 private List<StrutsForward> __getActionForwards8r; 1711 private boolean __getActionForwards8rSet = false; 1712 1713 /** 1714 * Represents a Struts action. Such an action typically is associated with a form bean. 1715 * This action model element extends a transition, but the actual logic contained by the action 1716 * envelops all action states called, until either a final state or JSP page is reached. 1717 * @return (List<StrutsForward>)handleGetActionForwards() 1718 */ 1719 public final List<StrutsForward> getActionForwards() 1720 { 1721 List<StrutsForward> getActionForwards8r = this.__getActionForwards8r; 1722 if (!this.__getActionForwards8rSet) 1723 { 1724 // strutsAction has no pre constraints 1725 List result = handleGetActionForwards(); 1726 List shieldedResult = this.shieldedElements(result); 1727 try 1728 { 1729 getActionForwards8r = (List<StrutsForward>)shieldedResult; 1730 } 1731 catch (ClassCastException ex) 1732 { 1733 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1734 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getActionForwards List<StrutsForward> " + result + ": " + shieldedResult); 1735 } 1736 // strutsAction has no post constraints 1737 this.__getActionForwards8r = getActionForwards8r; 1738 if (isMetafacadePropertyCachingEnabled()) 1739 { 1740 this.__getActionForwards8rSet = true; 1741 } 1742 } 1743 return getActionForwards8r; 1744 } 1745 1746 /** 1747 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type 1748 * @return List 1749 */ 1750 protected abstract List handleGetActionForwards(); 1751 1752 /** 1753 * Represents a Struts action. Such an action typically is associated with a form bean. 1754 * This action model element extends a transition, but the actual logic contained by the action 1755 * envelops all action states called, until either a final state or JSP page is reached. 1756 * @return (List<StrutsParameter>)handleGetHiddenActionParameters() 1757 */ 1758 public final List<StrutsParameter> getHiddenActionParameters() 1759 { 1760 List<StrutsParameter> getHiddenActionParameters9r = null; 1761 // strutsAction has no pre constraints 1762 List result = handleGetHiddenActionParameters(); 1763 List shieldedResult = this.shieldedElements(result); 1764 try 1765 { 1766 getHiddenActionParameters9r = (List<StrutsParameter>)shieldedResult; 1767 } 1768 catch (ClassCastException ex) 1769 { 1770 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1771 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getHiddenActionParameters List<StrutsParameter> " + result + ": " + shieldedResult); 1772 } 1773 // strutsAction has no post constraints 1774 return getHiddenActionParameters9r; 1775 } 1776 1777 /** 1778 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type 1779 * @return List 1780 */ 1781 protected abstract List handleGetHiddenActionParameters(); 1782 1783 private StrutsController __getController10r; 1784 private boolean __getController10rSet = false; 1785 1786 /** 1787 * Represents a Struts action. Such an action typically is associated with a form bean. 1788 * This action model element extends a transition, but the actual logic contained by the action 1789 * envelops all action states called, until either a final state or JSP page is reached. 1790 * @return (StrutsController)handleGetController() 1791 */ 1792 public final StrutsController getController() 1793 { 1794 StrutsController getController10r = this.__getController10r; 1795 if (!this.__getController10rSet) 1796 { 1797 // strutsAction has no pre constraints 1798 Object result = handleGetController(); 1799 MetafacadeBase shieldedResult = this.shieldedElement(result); 1800 try 1801 { 1802 getController10r = (StrutsController)shieldedResult; 1803 } 1804 catch (ClassCastException ex) 1805 { 1806 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1807 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getController StrutsController " + result + ": " + shieldedResult); 1808 } 1809 // strutsAction has no post constraints 1810 this.__getController10r = getController10r; 1811 if (isMetafacadePropertyCachingEnabled()) 1812 { 1813 this.__getController10rSet = true; 1814 } 1815 } 1816 return getController10r; 1817 } 1818 1819 /** 1820 * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type 1821 * @return Object 1822 */ 1823 protected abstract Object handleGetController(); 1824 1825 private List<StrutsActionState> __getActionStates11r; 1826 private boolean __getActionStates11rSet = false; 1827 1828 /** 1829 * Represents a Struts action. Such an action typically is associated with a form bean. 1830 * This action model element extends a transition, but the actual logic contained by the action 1831 * envelops all action states called, until either a final state or JSP page is reached. 1832 * @return (List<StrutsActionState>)handleGetActionStates() 1833 */ 1834 public final List<StrutsActionState> getActionStates() 1835 { 1836 List<StrutsActionState> getActionStates11r = this.__getActionStates11r; 1837 if (!this.__getActionStates11rSet) 1838 { 1839 // strutsAction has no pre constraints 1840 List result = handleGetActionStates(); 1841 List shieldedResult = this.shieldedElements(result); 1842 try 1843 { 1844 getActionStates11r = (List<StrutsActionState>)shieldedResult; 1845 } 1846 catch (ClassCastException ex) 1847 { 1848 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1849 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getActionStates List<StrutsActionState> " + result + ": " + shieldedResult); 1850 } 1851 // strutsAction has no post constraints 1852 this.__getActionStates11r = getActionStates11r; 1853 if (isMetafacadePropertyCachingEnabled()) 1854 { 1855 this.__getActionStates11rSet = true; 1856 } 1857 } 1858 return getActionStates11r; 1859 } 1860 1861 /** 1862 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type 1863 * @return List 1864 */ 1865 protected abstract List handleGetActionStates(); 1866 1867 private StrutsParameter __getTableLinkParameter12r; 1868 private boolean __getTableLinkParameter12rSet = false; 1869 1870 /** 1871 * Those actions that are working on this table and are to be represented as hyperlinks. It only 1872 * makes sense to call this property on parameters that represent a table page-variable. 1873 * @return (StrutsParameter)handleGetTableLinkParameter() 1874 */ 1875 public final StrutsParameter getTableLinkParameter() 1876 { 1877 StrutsParameter getTableLinkParameter12r = this.__getTableLinkParameter12r; 1878 if (!this.__getTableLinkParameter12rSet) 1879 { 1880 // tableHyperlinkActions has no pre constraints 1881 Object result = handleGetTableLinkParameter(); 1882 MetafacadeBase shieldedResult = this.shieldedElement(result); 1883 try 1884 { 1885 getTableLinkParameter12r = (StrutsParameter)shieldedResult; 1886 } 1887 catch (ClassCastException ex) 1888 { 1889 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1890 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getTableLinkParameter StrutsParameter " + result + ": " + shieldedResult); 1891 } 1892 // tableHyperlinkActions has no post constraints 1893 this.__getTableLinkParameter12r = getTableLinkParameter12r; 1894 if (isMetafacadePropertyCachingEnabled()) 1895 { 1896 this.__getTableLinkParameter12rSet = true; 1897 } 1898 } 1899 return getTableLinkParameter12r; 1900 } 1901 1902 /** 1903 * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type 1904 * @return Object 1905 */ 1906 protected abstract Object handleGetTableLinkParameter(); 1907 1908 private List<StrutsForward> __getDecisionTransitions13r; 1909 private boolean __getDecisionTransitions13rSet = false; 1910 1911 /** 1912 * Represents a Struts action. Such an action typically is associated with a form bean. 1913 * This action model element extends a transition, but the actual logic contained by the action 1914 * envelops all action states called, until either a final state or JSP page is reached. 1915 * @return (List<StrutsForward>)handleGetDecisionTransitions() 1916 */ 1917 public final List<StrutsForward> getDecisionTransitions() 1918 { 1919 List<StrutsForward> getDecisionTransitions13r = this.__getDecisionTransitions13r; 1920 if (!this.__getDecisionTransitions13rSet) 1921 { 1922 // strutsAction has no pre constraints 1923 List result = handleGetDecisionTransitions(); 1924 List shieldedResult = this.shieldedElements(result); 1925 try 1926 { 1927 getDecisionTransitions13r = (List<StrutsForward>)shieldedResult; 1928 } 1929 catch (ClassCastException ex) 1930 { 1931 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1932 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getDecisionTransitions List<StrutsForward> " + result + ": " + shieldedResult); 1933 } 1934 // strutsAction has no post constraints 1935 this.__getDecisionTransitions13r = getDecisionTransitions13r; 1936 if (isMetafacadePropertyCachingEnabled()) 1937 { 1938 this.__getDecisionTransitions13rSet = true; 1939 } 1940 } 1941 return getDecisionTransitions13r; 1942 } 1943 1944 /** 1945 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type 1946 * @return List 1947 */ 1948 protected abstract List handleGetDecisionTransitions(); 1949 1950 private List<StrutsForward> __getTransitions14r; 1951 private boolean __getTransitions14rSet = false; 1952 1953 /** 1954 * Represents a Struts action. Such an action typically is associated with a form bean. 1955 * This action model element extends a transition, but the actual logic contained by the action 1956 * envelops all action states called, until either a final state or JSP page is reached. 1957 * @return (List<StrutsForward>)handleGetTransitions() 1958 */ 1959 public final List<StrutsForward> getTransitions() 1960 { 1961 List<StrutsForward> getTransitions14r = this.__getTransitions14r; 1962 if (!this.__getTransitions14rSet) 1963 { 1964 // strutsAction has no pre constraints 1965 List result = handleGetTransitions(); 1966 List shieldedResult = this.shieldedElements(result); 1967 try 1968 { 1969 getTransitions14r = (List<StrutsForward>)shieldedResult; 1970 } 1971 catch (ClassCastException ex) 1972 { 1973 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 1974 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getTransitions List<StrutsForward> " + result + ": " + shieldedResult); 1975 } 1976 // strutsAction has no post constraints 1977 this.__getTransitions14r = getTransitions14r; 1978 if (isMetafacadePropertyCachingEnabled()) 1979 { 1980 this.__getTransitions14rSet = true; 1981 } 1982 } 1983 return getTransitions14r; 1984 } 1985 1986 /** 1987 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type 1988 * @return List 1989 */ 1990 protected abstract List handleGetTransitions(); 1991 1992 private List<StrutsParameter> __getActionFormFields15r; 1993 private boolean __getActionFormFields15rSet = false; 1994 1995 /** 1996 * Represents a Struts action. Such an action typically is associated with a form bean. 1997 * This action model element extends a transition, but the actual logic contained by the action 1998 * envelops all action states called, until either a final state or JSP page is reached. 1999 * @return (List<StrutsParameter>)handleGetActionFormFields() 2000 */ 2001 public final List<StrutsParameter> getActionFormFields() 2002 { 2003 List<StrutsParameter> getActionFormFields15r = this.__getActionFormFields15r; 2004 if (!this.__getActionFormFields15rSet) 2005 { 2006 // strutsAction has no pre constraints 2007 List result = handleGetActionFormFields(); 2008 List shieldedResult = this.shieldedElements(result); 2009 try 2010 { 2011 getActionFormFields15r = (List<StrutsParameter>)shieldedResult; 2012 } 2013 catch (ClassCastException ex) 2014 { 2015 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 2016 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getActionFormFields List<StrutsParameter> " + result + ": " + shieldedResult); 2017 } 2018 // strutsAction has no post constraints 2019 this.__getActionFormFields15r = getActionFormFields15r; 2020 if (isMetafacadePropertyCachingEnabled()) 2021 { 2022 this.__getActionFormFields15rSet = true; 2023 } 2024 } 2025 return getActionFormFields15r; 2026 } 2027 2028 /** 2029 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type 2030 * @return List 2031 */ 2032 protected abstract List handleGetActionFormFields(); 2033 2034 private StrutsTrigger __getActionTrigger16r; 2035 private boolean __getActionTrigger16rSet = false; 2036 2037 /** 2038 * If isActionTrigger() returns true them this association points to the action to which the 2039 * trigger has been associated. 2040 * @return (StrutsTrigger)handleGetActionTrigger() 2041 */ 2042 public final StrutsTrigger getActionTrigger() 2043 { 2044 StrutsTrigger getActionTrigger16r = this.__getActionTrigger16r; 2045 if (!this.__getActionTrigger16rSet) 2046 { 2047 // strutsAction has no pre constraints 2048 Object result = handleGetActionTrigger(); 2049 MetafacadeBase shieldedResult = this.shieldedElement(result); 2050 try 2051 { 2052 getActionTrigger16r = (StrutsTrigger)shieldedResult; 2053 } 2054 catch (ClassCastException ex) 2055 { 2056 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 2057 StrutsActionLogic.logger.warn("incorrect metafacade cast for StrutsActionLogic.getActionTrigger StrutsTrigger " + result + ": " + shieldedResult); 2058 } 2059 // strutsAction has no post constraints 2060 this.__getActionTrigger16r = getActionTrigger16r; 2061 if (isMetafacadePropertyCachingEnabled()) 2062 { 2063 this.__getActionTrigger16rSet = true; 2064 } 2065 } 2066 return getActionTrigger16r; 2067 } 2068 2069 /** 2070 * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type 2071 * @return Object 2072 */ 2073 protected abstract Object handleGetActionTrigger(); 2074 2075 /** 2076 * <p><b>Constraint:</b> org::andromda::cartridges::bpm4struts::metafacades::StrutsAction::each action must carry a trigger</p> 2077 * <p><b>Error:</b> Each action transition coming out of a page must have a trigger (the name could be sufficient), it is recommended to add a trigger of type 'signal'.</p> 2078 * <p><b>OCL:</b> context StrutsAction inv: exitingPage implies triggerPresent</p> 2079 * <p><b>Constraint:</b> org::andromda::cartridges::bpm4struts::metafacades::StrutsAction::table links must target an existing table page-variable</p> 2080 * <p><b>Error:</b> When specifying a table link for this action you will need to target a table page-variable from the input page, the specified table does not exist in that page.</p> 2081 * <p><b>OCL:</b> context StrutsAction inv: tableLinkName->notEmpty() implies tableLink</p> 2082 * <p><b>Constraint:</b> org::andromda::cartridges::bpm4struts::metafacades::StrutsAction::hyperlink table actions need to indicate the column</p> 2083 * <p><b>Error:</b> This hyperlink table event is not specifying the target column name on the table link, you will need to do this in order to determine in which column to render the hyperlink.</p> 2084 * <p><b>OCL:</b> context StrutsAction inv: (hyperlink and tableLink) implies tableLinkColumnName->notEmpty()</p> 2085 * @param validationMessages Collection<ModelValidationMessage> 2086 * @see StrutsForwardLogicImpl#validateInvariants(Collection validationMessages) 2087 */ 2088 @Override 2089 public void validateInvariants(Collection<ModelValidationMessage> validationMessages) 2090 { 2091 super.validateInvariants(validationMessages); 2092 try 2093 { 2094 final Object contextElement = this.THIS(); 2095 boolean constraintValid = OCLResultEnsurer.ensure((Boolean.valueOf(String.valueOf(Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"exitingPage"))).booleanValue())).booleanValue()?Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"triggerPresent"))).booleanValue():true)); 2096 if (!constraintValid) 2097 { 2098 validationMessages.add( 2099 new ModelValidationMessage( 2100 (MetafacadeBase)contextElement , 2101 "org::andromda::cartridges::bpm4struts::metafacades::StrutsAction::each action must carry a trigger", 2102 "Each action transition coming out of a page must have a trigger (the name could be sufficient), it is recommended to add a trigger of type 'signal'.")); 2103 } 2104 } 2105 catch (Throwable th) 2106 { 2107 Throwable cause = th.getCause(); 2108 int depth = 0; // Some throwables have infinite recursion 2109 while (cause != null && depth < 7) 2110 { 2111 th = cause; 2112 depth++; 2113 } 2114 logger.error("Error validating constraint 'org::andromda::cartridges::bpm4struts::metafacades::StrutsAction::each action must carry a trigger' ON " 2115 + this.THIS().toString() + ": " + th.getMessage(), th); 2116 } 2117 try 2118 { 2119 final Object contextElement = this.THIS(); 2120 boolean constraintValid = OCLResultEnsurer.ensure((Boolean.valueOf(String.valueOf(OCLCollections.notEmpty(OCLIntrospector.invoke(contextElement,"tableLinkName")))).booleanValue()?Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"tableLink"))).booleanValue():true)); 2121 if (!constraintValid) 2122 { 2123 validationMessages.add( 2124 new ModelValidationMessage( 2125 (MetafacadeBase)contextElement , 2126 "org::andromda::cartridges::bpm4struts::metafacades::StrutsAction::table links must target an existing table page-variable", 2127 "When specifying a table link for this action you will need to target a table page-variable from the input page, the specified table does not exist in that page.")); 2128 } 2129 } 2130 catch (Throwable th) 2131 { 2132 Throwable cause = th.getCause(); 2133 int depth = 0; // Some throwables have infinite recursion 2134 while (cause != null && depth < 7) 2135 { 2136 th = cause; 2137 depth++; 2138 } 2139 logger.error("Error validating constraint 'org::andromda::cartridges::bpm4struts::metafacades::StrutsAction::table links must target an existing table page-variable' ON " 2140 + this.THIS().toString() + ": " + th.getMessage(), th); 2141 } 2142 try 2143 { 2144 final Object contextElement = this.THIS(); 2145 boolean constraintValid = OCLResultEnsurer.ensure((Boolean.valueOf(String.valueOf((Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"hyperlink"))).booleanValue()&&Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"tableLink"))).booleanValue()))).booleanValue()?OCLCollections.notEmpty(OCLIntrospector.invoke(contextElement,"tableLinkColumnName")):true)); 2146 if (!constraintValid) 2147 { 2148 validationMessages.add( 2149 new ModelValidationMessage( 2150 (MetafacadeBase)contextElement , 2151 "org::andromda::cartridges::bpm4struts::metafacades::StrutsAction::hyperlink table actions need to indicate the column", 2152 "This hyperlink table event is not specifying the target column name on the table link, you will need to do this in order to determine in which column to render the hyperlink.")); 2153 } 2154 } 2155 catch (Throwable th) 2156 { 2157 Throwable cause = th.getCause(); 2158 int depth = 0; // Some throwables have infinite recursion 2159 while (cause != null && depth < 7) 2160 { 2161 th = cause; 2162 depth++; 2163 } 2164 logger.error("Error validating constraint 'org::andromda::cartridges::bpm4struts::metafacades::StrutsAction::hyperlink table actions need to indicate the column' ON " 2165 + this.THIS().toString() + ": " + th.getMessage(), th); 2166 } 2167 } 2168}