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 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.FrontEndActivityGraph; 020import org.andromda.metafacades.uml.FrontEndControllerOperation; 021import org.andromda.metafacades.uml.FrontEndEvent; 022import org.andromda.metafacades.uml.FrontEndForward; 023import org.andromda.metafacades.uml.FrontEndParameter; 024import org.andromda.metafacades.uml.FrontEndUseCase; 025import org.andromda.metafacades.uml.GuardFacade; 026import org.andromda.metafacades.uml.ModelElementFacade; 027import org.andromda.metafacades.uml.ModelFacade; 028import org.andromda.metafacades.uml.PackageFacade; 029import org.andromda.metafacades.uml.PseudostateFacade; 030import org.andromda.metafacades.uml.StateMachineFacade; 031import org.andromda.metafacades.uml.StateVertexFacade; 032import org.andromda.metafacades.uml.StereotypeFacade; 033import org.andromda.metafacades.uml.TaggedValueFacade; 034import org.andromda.metafacades.uml.TemplateParameterFacade; 035import org.andromda.metafacades.uml.TypeMappings; 036import org.andromda.translation.ocl.validation.OCLCollections; 037import org.andromda.translation.ocl.validation.OCLIntrospector; 038import org.andromda.translation.ocl.validation.OCLResultEnsurer; 039import org.apache.log4j.Logger; 040 041/** 042 * A Struts forward is any transition between states. Some of these forwards may end up as actual 043 * forwards in the Struts deployment descriptor. 044 * MetafacadeLogic for StrutsForward 045 * 046 * @see StrutsForward 047 */ 048public abstract class StrutsForwardLogic 049 extends MetafacadeBase 050 implements StrutsForward 051{ 052 /** 053 * The underlying UML object 054 * @see Object 055 */ 056 protected Object metaObject; 057 058 /** Create Metafacade implementation instance using the MetafacadeFactory from the context 059 * @param metaObjectIn 060 * @param context 061 */ 062 protected StrutsForwardLogic(Object metaObjectIn, String context) 063 { 064 super(metaObjectIn, getContext(context)); 065 this.superFrontEndForward = 066 (FrontEndForward) 067 MetafacadeFactory.getInstance().createFacadeImpl( 068 "org.andromda.metafacades.uml.FrontEndForward", 069 metaObjectIn, 070 getContext(context)); 071 this.metaObject = metaObjectIn; 072 } 073 074 /** 075 * The logger instance. 076 */ 077 private static final Logger logger = Logger.getLogger(StrutsForwardLogic.class); 078 079 /** 080 * Gets the context for this metafacade logic instance. 081 * @param context String. Set to StrutsForward if null 082 * @return context String 083 */ 084 private static String getContext(String context) 085 { 086 if (context == null) 087 { 088 context = "org.andromda.cartridges.bpm4struts.metafacades.StrutsForward"; 089 } 090 return context; 091 } 092 093 private FrontEndForward superFrontEndForward; 094 private boolean superFrontEndForwardInitialized = false; 095 096 /** 097 * Gets the FrontEndForward parent instance. 098 * @return this.superFrontEndForward FrontEndForward 099 */ 100 private FrontEndForward getSuperFrontEndForward() 101 { 102 if (!this.superFrontEndForwardInitialized) 103 { 104 ((MetafacadeBase)this.superFrontEndForward).setMetafacadeContext(this.getMetafacadeContext()); 105 this.superFrontEndForwardInitialized = true; 106 } 107 return this.superFrontEndForward; 108 } 109 110 /** Reset context only for non-root metafacades 111 * @param context 112 * @see MetafacadeBase#resetMetafacadeContext(String context) 113 */ 114 @Override 115 public void resetMetafacadeContext(String context) 116 { 117 if (!this.contextRoot) // reset context only for non-root metafacades 118 { 119 context = getContext(context); // to have same value as in original constructor call 120 setMetafacadeContext (context); 121 if (this.superFrontEndForwardInitialized) 122 { 123 ((MetafacadeBase)this.superFrontEndForward).resetMetafacadeContext(context); 124 } 125 } 126 } 127 128 /** 129 * @return boolean true always 130 * @see StrutsForward 131 */ 132 public boolean isStrutsForwardMetaType() 133 { 134 return true; 135 } 136 137 // --------------- attributes --------------------- 138 139 /** 140 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsForward#getForwardName() 141 * @return String 142 */ 143 protected abstract String handleGetForwardName(); 144 145 private String __forwardName1a; 146 private boolean __forwardName1aSet = false; 147 148 /** 149 * The name for this forward. This name is always lowercase and words are separated using dots, 150 * not unlike the convention for Java package names. 151 * @return (String)handleGetForwardName() 152 */ 153 public final String getForwardName() 154 { 155 String forwardName1a = this.__forwardName1a; 156 if (!this.__forwardName1aSet) 157 { 158 // forwardName has no pre constraints 159 forwardName1a = handleGetForwardName(); 160 // forwardName has no post constraints 161 this.__forwardName1a = forwardName1a; 162 if (isMetafacadePropertyCachingEnabled()) 163 { 164 this.__forwardName1aSet = true; 165 } 166 } 167 return forwardName1a; 168 } 169 170 /** 171 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsForward#getForwardPath() 172 * @return String 173 */ 174 protected abstract String handleGetForwardPath(); 175 176 private String __forwardPath2a; 177 private boolean __forwardPath2aSet = false; 178 179 /** 180 * Returns the path targetted by this forward. 181 * @return (String)handleGetForwardPath() 182 */ 183 public final String getForwardPath() 184 { 185 String forwardPath2a = this.__forwardPath2a; 186 if (!this.__forwardPath2aSet) 187 { 188 // forwardPath has no pre constraints 189 forwardPath2a = handleGetForwardPath(); 190 // forwardPath has no post constraints 191 this.__forwardPath2a = forwardPath2a; 192 if (isMetafacadePropertyCachingEnabled()) 193 { 194 this.__forwardPath2aSet = true; 195 } 196 } 197 return forwardPath2a; 198 } 199 200 /** 201 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsForward#getGuardName() 202 * @return String 203 */ 204 protected abstract String handleGetGuardName(); 205 206 private String __guardName3a; 207 private boolean __guardName3aSet = false; 208 209 /** 210 * If this forward is guarded (such as with decision points) this method return the name of that 211 * guard. 212 * @return (String)handleGetGuardName() 213 */ 214 public final String getGuardName() 215 { 216 String guardName3a = this.__guardName3a; 217 if (!this.__guardName3aSet) 218 { 219 // guardName has no pre constraints 220 guardName3a = handleGetGuardName(); 221 // guardName has no post constraints 222 this.__guardName3a = guardName3a; 223 if (isMetafacadePropertyCachingEnabled()) 224 { 225 this.__guardName3aSet = true; 226 } 227 } 228 return guardName3a; 229 } 230 231 /** 232 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsForward#isEnteringPage() 233 * @return boolean 234 */ 235 protected abstract boolean handleIsEnteringPage(); 236 237 private boolean __enteringPage4a; 238 private boolean __enteringPage4aSet = false; 239 240 /** 241 * True if this action directly targets a JSP page, false otherwise. 242 * @return (boolean)handleIsEnteringPage() 243 */ 244 public final boolean isEnteringPage() 245 { 246 boolean enteringPage4a = this.__enteringPage4a; 247 if (!this.__enteringPage4aSet) 248 { 249 // enteringPage has no pre constraints 250 enteringPage4a = handleIsEnteringPage(); 251 // enteringPage has no post constraints 252 this.__enteringPage4a = enteringPage4a; 253 if (isMetafacadePropertyCachingEnabled()) 254 { 255 this.__enteringPage4aSet = true; 256 } 257 } 258 return enteringPage4a; 259 } 260 261 /** 262 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsForward#getTargetNameKey() 263 * @return String 264 */ 265 protected abstract String handleGetTargetNameKey(); 266 267 private String __targetNameKey5a; 268 private boolean __targetNameKey5aSet = false; 269 270 /** 271 * The resource bundle key of the name for the target element. This method returns the key for 272 * the use-case or jsp page. If targetting anything else this method returns null. 273 * @return (String)handleGetTargetNameKey() 274 */ 275 public final String getTargetNameKey() 276 { 277 String targetNameKey5a = this.__targetNameKey5a; 278 if (!this.__targetNameKey5aSet) 279 { 280 // targetNameKey has no pre constraints 281 targetNameKey5a = handleGetTargetNameKey(); 282 // targetNameKey has no post constraints 283 this.__targetNameKey5a = targetNameKey5a; 284 if (isMetafacadePropertyCachingEnabled()) 285 { 286 this.__targetNameKey5aSet = true; 287 } 288 } 289 return targetNameKey5a; 290 } 291 292 /** 293 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsForward#isExitingPage() 294 * @return boolean 295 */ 296 protected abstract boolean handleIsExitingPage(); 297 298 private boolean __exitingPage6a; 299 private boolean __exitingPage6aSet = false; 300 301 /** 302 * Whether or not this forward (transition) is coming out of a page. 303 * @return (boolean)handleIsExitingPage() 304 */ 305 public final boolean isExitingPage() 306 { 307 boolean exitingPage6a = this.__exitingPage6a; 308 if (!this.__exitingPage6aSet) 309 { 310 // exitingPage has no pre constraints 311 exitingPage6a = handleIsExitingPage(); 312 // exitingPage has no post constraints 313 this.__exitingPage6a = exitingPage6a; 314 if (isMetafacadePropertyCachingEnabled()) 315 { 316 this.__exitingPage6aSet = true; 317 } 318 } 319 return exitingPage6a; 320 } 321 322 /** 323 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsForward#getSuccessMessages() 324 * @return Map 325 */ 326 protected abstract Map handleGetSuccessMessages(); 327 328 private Map __successMessages7a; 329 private boolean __successMessages7aSet = false; 330 331 /** 332 * A map of key=value pairs, one for each success message. 333 * @return (Map)handleGetSuccessMessages() 334 */ 335 public final Map getSuccessMessages() 336 { 337 Map successMessages7a = this.__successMessages7a; 338 if (!this.__successMessages7aSet) 339 { 340 // successMessages has no pre constraints 341 successMessages7a = handleGetSuccessMessages(); 342 // successMessages has no post constraints 343 this.__successMessages7a = successMessages7a; 344 if (isMetafacadePropertyCachingEnabled()) 345 { 346 this.__successMessages7aSet = true; 347 } 348 } 349 return successMessages7a; 350 } 351 352 /** 353 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsForward#getWarningMessages() 354 * @return Map 355 */ 356 protected abstract Map handleGetWarningMessages(); 357 358 private Map __warningMessages8a; 359 private boolean __warningMessages8aSet = false; 360 361 /** 362 * A map of key=value pairs, one for each warning message. 363 * @return (Map)handleGetWarningMessages() 364 */ 365 public final Map getWarningMessages() 366 { 367 Map warningMessages8a = this.__warningMessages8a; 368 if (!this.__warningMessages8aSet) 369 { 370 // warningMessages has no pre constraints 371 warningMessages8a = handleGetWarningMessages(); 372 // warningMessages has no post constraints 373 this.__warningMessages8a = warningMessages8a; 374 if (isMetafacadePropertyCachingEnabled()) 375 { 376 this.__warningMessages8aSet = true; 377 } 378 } 379 return warningMessages8a; 380 } 381 382 /** 383 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsForward#isWarningMessagesPresent() 384 * @return boolean 385 */ 386 protected abstract boolean handleIsWarningMessagesPresent(); 387 388 private boolean __warningMessagesPresent9a; 389 private boolean __warningMessagesPresent9aSet = false; 390 391 /** 392 * TODO: Model Documentation for 393 * org.andromda.cartridges.bpm4struts.metafacades.StrutsForward.warningMessagesPresent 394 * @return (boolean)handleIsWarningMessagesPresent() 395 */ 396 public final boolean isWarningMessagesPresent() 397 { 398 boolean warningMessagesPresent9a = this.__warningMessagesPresent9a; 399 if (!this.__warningMessagesPresent9aSet) 400 { 401 // warningMessagesPresent has no pre constraints 402 warningMessagesPresent9a = handleIsWarningMessagesPresent(); 403 // warningMessagesPresent has no post constraints 404 this.__warningMessagesPresent9a = warningMessagesPresent9a; 405 if (isMetafacadePropertyCachingEnabled()) 406 { 407 this.__warningMessagesPresent9aSet = true; 408 } 409 } 410 return warningMessagesPresent9a; 411 } 412 413 /** 414 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsForward#isSuccessMessagesPresent() 415 * @return boolean 416 */ 417 protected abstract boolean handleIsSuccessMessagesPresent(); 418 419 private boolean __successMessagesPresent10a; 420 private boolean __successMessagesPresent10aSet = false; 421 422 /** 423 * TODO: Model Documentation for 424 * org.andromda.cartridges.bpm4struts.metafacades.StrutsForward.successMessagesPresent 425 * @return (boolean)handleIsSuccessMessagesPresent() 426 */ 427 public final boolean isSuccessMessagesPresent() 428 { 429 boolean successMessagesPresent10a = this.__successMessagesPresent10a; 430 if (!this.__successMessagesPresent10aSet) 431 { 432 // successMessagesPresent has no pre constraints 433 successMessagesPresent10a = handleIsSuccessMessagesPresent(); 434 // successMessagesPresent has no post constraints 435 this.__successMessagesPresent10a = successMessagesPresent10a; 436 if (isMetafacadePropertyCachingEnabled()) 437 { 438 this.__successMessagesPresent10aSet = true; 439 } 440 } 441 return successMessagesPresent10a; 442 } 443 444 // ------------- associations ------------------ 445 446 private StrutsActivityGraph __getStrutsActivityGraph1r; 447 private boolean __getStrutsActivityGraph1rSet = false; 448 449 /** 450 * A Struts forward is any transition between states. Some of these forwards may end up as 451 * actual 452 * forwards in the Struts deployment descriptor. 453 * @return (StrutsActivityGraph)handleGetStrutsActivityGraph() 454 */ 455 public final StrutsActivityGraph getStrutsActivityGraph() 456 { 457 StrutsActivityGraph getStrutsActivityGraph1r = this.__getStrutsActivityGraph1r; 458 if (!this.__getStrutsActivityGraph1rSet) 459 { 460 // strutsForward has no pre constraints 461 Object result = handleGetStrutsActivityGraph(); 462 MetafacadeBase shieldedResult = this.shieldedElement(result); 463 try 464 { 465 getStrutsActivityGraph1r = (StrutsActivityGraph)shieldedResult; 466 } 467 catch (ClassCastException ex) 468 { 469 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn 470 StrutsForwardLogic.logger.warn("incorrect metafacade cast for StrutsForwardLogic.getStrutsActivityGraph StrutsActivityGraph " + result + ": " + shieldedResult); 471 } 472 // strutsForward has no post constraints 473 this.__getStrutsActivityGraph1r = getStrutsActivityGraph1r; 474 if (isMetafacadePropertyCachingEnabled()) 475 { 476 this.__getStrutsActivityGraph1rSet = true; 477 } 478 } 479 return getStrutsActivityGraph1r; 480 } 481 482 /** 483 * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type 484 * @return Object 485 */ 486 protected abstract Object handleGetStrutsActivityGraph(); 487 488 /** 489 * @return true 490 * @see FrontEndForward 491 */ 492 public boolean isFrontEndForwardMetaType() 493 { 494 return true; 495 } 496 497 /** 498 * @return true 499 * @see org.andromda.metafacades.uml.TransitionFacade 500 */ 501 public boolean isTransitionFacadeMetaType() 502 { 503 return true; 504 } 505 506 /** 507 * @return true 508 * @see ModelElementFacade 509 */ 510 public boolean isModelElementFacadeMetaType() 511 { 512 return true; 513 } 514 515 // ----------- delegates to FrontEndForward ------------ 516 /** 517 * The method name used to delegate to this forward. 518 * @see FrontEndForward#getActionMethodName() 519 */ 520 public String getActionMethodName() 521 { 522 return this.getSuperFrontEndForward().getActionMethodName(); 523 } 524 525 /** 526 * The front-end actions directly containing this front-end forward. 527 * @see FrontEndForward#getActions() 528 */ 529 public List<FrontEndAction> getActions() 530 { 531 return this.getSuperFrontEndForward().getActions(); 532 } 533 534 /** 535 * The trigger for this front-end forward. 536 * @see FrontEndForward#getDecisionTrigger() 537 */ 538 public FrontEndEvent getDecisionTrigger() 539 { 540 return this.getSuperFrontEndForward().getDecisionTrigger(); 541 } 542 543 /** 544 * Tthe set of parameter used during transport in this forward. 545 * @see FrontEndForward#getForwardParameters() 546 */ 547 public List<FrontEndParameter> getForwardParameters() 548 { 549 return this.getSuperFrontEndForward().getForwardParameters(); 550 } 551 552 /** 553 * The activity graph which holds this forward if the graph is contained in a FrontEndUseCase. 554 * @see FrontEndForward#getFrontEndActivityGraph() 555 */ 556 public FrontEndActivityGraph getFrontEndActivityGraph() 557 { 558 return this.getSuperFrontEndForward().getFrontEndActivityGraph(); 559 } 560 561 /** 562 * The operation to which is called during execution of this front-end forward. 563 * @see FrontEndForward#getOperationCall() 564 */ 565 public FrontEndControllerOperation getOperationCall() 566 { 567 return this.getSuperFrontEndForward().getOperationCall(); 568 } 569 570 /** 571 * The use case in which this forward is contained. 572 * @see FrontEndForward#getUseCase() 573 */ 574 public FrontEndUseCase getUseCase() 575 { 576 return this.getSuperFrontEndForward().getUseCase(); 577 } 578 579 /** 580 * Indicates if this forward is contained in a FrontEndUseCase. 581 * @see FrontEndForward#isContainedInFrontEndUseCase() 582 */ 583 public boolean isContainedInFrontEndUseCase() 584 { 585 return this.getSuperFrontEndForward().isContainedInFrontEndUseCase(); 586 } 587 588 /** 589 * Indicates if this action directly targets a "front-end" view, false otherwise. 590 * @see FrontEndForward#isEnteringView() 591 */ 592 public boolean isEnteringView() 593 { 594 return this.getSuperFrontEndForward().isEnteringView(); 595 } 596 597 /** 598 * Indicates if this forward (transition) is coming out of a front-end view. 599 * @see FrontEndForward#isExitingView() 600 */ 601 public boolean isExitingView() 602 { 603 return this.getSuperFrontEndForward().isExitingView(); 604 } 605 606 /** 607 * Copies all tagged values from the given ModelElementFacade to this model element facade. 608 * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element) 609 */ 610 public void copyTaggedValues(ModelElementFacade element) 611 { 612 this.getSuperFrontEndForward().copyTaggedValues(element); 613 } 614 615 /** 616 * Finds the tagged value with the specified 'tagName'. In case there are more values the first 617 * one found will be returned. 618 * @see ModelElementFacade#findTaggedValue(String tagName) 619 */ 620 public Object findTaggedValue(String tagName) 621 { 622 return this.getSuperFrontEndForward().findTaggedValue(tagName); 623 } 624 625 /** 626 * Returns all the values for the tagged value with the specified name. The returned collection 627 * will contains only String instances, or will be empty. Never null. 628 * @see ModelElementFacade#findTaggedValues(String tagName) 629 */ 630 public Collection<Object> findTaggedValues(String tagName) 631 { 632 return this.getSuperFrontEndForward().findTaggedValues(tagName); 633 } 634 635 /** 636 * Returns the fully qualified name of the model element. The fully qualified name includes 637 * complete package qualified name of the underlying model element. The templates parameter will 638 * be replaced by the correct one given the binding relation of the parameter to this element. 639 * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement) 640 */ 641 public String getBindedFullyQualifiedName(ModelElementFacade bindedElement) 642 { 643 return this.getSuperFrontEndForward().getBindedFullyQualifiedName(bindedElement); 644 } 645 646 /** 647 * Gets all constraints belonging to the model element. 648 * @see ModelElementFacade#getConstraints() 649 */ 650 public Collection<ConstraintFacade> getConstraints() 651 { 652 return this.getSuperFrontEndForward().getConstraints(); 653 } 654 655 /** 656 * Returns the constraints of the argument kind that have been placed onto this model. Typical 657 * kinds are "inv", "pre" and "post". Other kinds are possible. 658 * @see ModelElementFacade#getConstraints(String kind) 659 */ 660 public Collection<ConstraintFacade> getConstraints(String kind) 661 { 662 return this.getSuperFrontEndForward().getConstraints(kind); 663 } 664 665 /** 666 * Gets the documentation for the model element, The indent argument is prefixed to each line. 667 * By default this method wraps lines after 64 characters. 668 * This method is equivalent to <code>getDocumentation(indent, 64)</code>. 669 * @see ModelElementFacade#getDocumentation(String indent) 670 */ 671 public String getDocumentation(String indent) 672 { 673 return this.getSuperFrontEndForward().getDocumentation(indent); 674 } 675 676 /** 677 * This method returns the documentation for this model element, with the lines wrapped after 678 * the specified number of characters, values of less than 1 will indicate no line wrapping is 679 * required. By default paragraphs are returned as HTML. 680 * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>. 681 * @see ModelElementFacade#getDocumentation(String indent, int lineLength) 682 */ 683 public String getDocumentation(String indent, int lineLength) 684 { 685 return this.getSuperFrontEndForward().getDocumentation(indent, lineLength); 686 } 687 688 /** 689 * This method returns the documentation for this model element, with the lines wrapped after 690 * the specified number of characters, values of less than 1 will indicate no line wrapping is 691 * required. HTML style determines if HTML Escaping is applied. 692 * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle) 693 */ 694 public String getDocumentation(String indent, int lineLength, boolean htmlStyle) 695 { 696 return this.getSuperFrontEndForward().getDocumentation(indent, lineLength, htmlStyle); 697 } 698 699 /** 700 * The fully qualified name of this model element. 701 * @see ModelElementFacade#getFullyQualifiedName() 702 */ 703 public String getFullyQualifiedName() 704 { 705 return this.getSuperFrontEndForward().getFullyQualifiedName(); 706 } 707 708 /** 709 * Returns the fully qualified name of the model element. The fully qualified name includes 710 * complete package qualified name of the underlying model element. If modelName is true, then 711 * the original name of the model element (the name contained within the model) will be the name 712 * returned, otherwise a name from a language mapping will be returned. 713 * @see ModelElementFacade#getFullyQualifiedName(boolean modelName) 714 */ 715 public String getFullyQualifiedName(boolean modelName) 716 { 717 return this.getSuperFrontEndForward().getFullyQualifiedName(modelName); 718 } 719 720 /** 721 * Returns the fully qualified name as a path, the returned value always starts with out a slash 722 * '/'. 723 * @see ModelElementFacade#getFullyQualifiedNamePath() 724 */ 725 public String getFullyQualifiedNamePath() 726 { 727 return this.getSuperFrontEndForward().getFullyQualifiedNamePath(); 728 } 729 730 /** 731 * Gets the unique identifier of the underlying model element. 732 * @see ModelElementFacade#getId() 733 */ 734 public String getId() 735 { 736 return this.getSuperFrontEndForward().getId(); 737 } 738 739 /** 740 * UML2: Retrieves the keywords for this element. Used to modify implementation properties which 741 * are not represented by other properties, i.e. native, transient, volatile, synchronized, 742 * (added annotations) override, deprecated. Can also be used to suppress compiler warnings: 743 * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require 744 * JDK5 compiler level. 745 * @see ModelElementFacade#getKeywords() 746 */ 747 public Collection<String> getKeywords() 748 { 749 return this.getSuperFrontEndForward().getKeywords(); 750 } 751 752 /** 753 * UML2: Retrieves a localized label for this named element. 754 * @see ModelElementFacade#getLabel() 755 */ 756 public String getLabel() 757 { 758 return this.getSuperFrontEndForward().getLabel(); 759 } 760 761 /** 762 * The language mappings that have been set for this model element. 763 * @see ModelElementFacade#getLanguageMappings() 764 */ 765 public TypeMappings getLanguageMappings() 766 { 767 return this.getSuperFrontEndForward().getLanguageMappings(); 768 } 769 770 /** 771 * Return the model containing this model element (multiple models may be loaded and processed 772 * at the same time). 773 * @see ModelElementFacade#getModel() 774 */ 775 public ModelFacade getModel() 776 { 777 return this.getSuperFrontEndForward().getModel(); 778 } 779 780 /** 781 * The name of the model element. 782 * @see ModelElementFacade#getName() 783 */ 784 public String getName() 785 { 786 return this.getSuperFrontEndForward().getName(); 787 } 788 789 /** 790 * Gets the package to which this model element belongs. 791 * @see ModelElementFacade#getPackage() 792 */ 793 public ModelElementFacade getPackage() 794 { 795 return this.getSuperFrontEndForward().getPackage(); 796 } 797 798 /** 799 * The name of this model element's package. 800 * @see ModelElementFacade#getPackageName() 801 */ 802 public String getPackageName() 803 { 804 return this.getSuperFrontEndForward().getPackageName(); 805 } 806 807 /** 808 * Gets the package name (optionally providing the ability to retrieve the model name and not 809 * the mapped name). 810 * @see ModelElementFacade#getPackageName(boolean modelName) 811 */ 812 public String getPackageName(boolean modelName) 813 { 814 return this.getSuperFrontEndForward().getPackageName(modelName); 815 } 816 817 /** 818 * Returns the package as a path, the returned value always starts with out a slash '/'. 819 * @see ModelElementFacade#getPackagePath() 820 */ 821 public String getPackagePath() 822 { 823 return this.getSuperFrontEndForward().getPackagePath(); 824 } 825 826 /** 827 * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the 828 * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from 829 * the names of the containing namespaces starting at the root of the hierarchy and ending with 830 * the name of the NamedElement itself. 831 * @see ModelElementFacade#getQualifiedName() 832 */ 833 public String getQualifiedName() 834 { 835 return this.getSuperFrontEndForward().getQualifiedName(); 836 } 837 838 /** 839 * Gets the root package for the model element. 840 * @see ModelElementFacade#getRootPackage() 841 */ 842 public PackageFacade getRootPackage() 843 { 844 return this.getSuperFrontEndForward().getRootPackage(); 845 } 846 847 /** 848 * Gets the dependencies for which this model element is the source. 849 * @see ModelElementFacade#getSourceDependencies() 850 */ 851 public Collection<DependencyFacade> getSourceDependencies() 852 { 853 return this.getSuperFrontEndForward().getSourceDependencies(); 854 } 855 856 /** 857 * If this model element is the context of an activity graph, this represents that activity 858 * graph. 859 * @see ModelElementFacade#getStateMachineContext() 860 */ 861 public StateMachineFacade getStateMachineContext() 862 { 863 return this.getSuperFrontEndForward().getStateMachineContext(); 864 } 865 866 /** 867 * The collection of ALL stereotype names for this model element. 868 * @see ModelElementFacade#getStereotypeNames() 869 */ 870 public Collection<String> getStereotypeNames() 871 { 872 return this.getSuperFrontEndForward().getStereotypeNames(); 873 } 874 875 /** 876 * Gets all stereotypes for this model element. 877 * @see ModelElementFacade#getStereotypes() 878 */ 879 public Collection<StereotypeFacade> getStereotypes() 880 { 881 return this.getSuperFrontEndForward().getStereotypes(); 882 } 883 884 /** 885 * Return the TaggedValues associated with this model element, under all stereotypes. 886 * @see ModelElementFacade#getTaggedValues() 887 */ 888 public Collection<TaggedValueFacade> getTaggedValues() 889 { 890 return this.getSuperFrontEndForward().getTaggedValues(); 891 } 892 893 /** 894 * Gets the dependencies for which this model element is the target. 895 * @see ModelElementFacade#getTargetDependencies() 896 */ 897 public Collection<DependencyFacade> getTargetDependencies() 898 { 899 return this.getSuperFrontEndForward().getTargetDependencies(); 900 } 901 902 /** 903 * Get the template parameter for this model element having the parameterName 904 * @see ModelElementFacade#getTemplateParameter(String parameterName) 905 */ 906 public Object getTemplateParameter(String parameterName) 907 { 908 return this.getSuperFrontEndForward().getTemplateParameter(parameterName); 909 } 910 911 /** 912 * Get the template parameters for this model element 913 * @see ModelElementFacade#getTemplateParameters() 914 */ 915 public Collection<TemplateParameterFacade> getTemplateParameters() 916 { 917 return this.getSuperFrontEndForward().getTemplateParameters(); 918 } 919 920 /** 921 * The visibility (i.e. public, private, protected or package) of the model element, will 922 * attempt a lookup for these values in the language mappings (if any). 923 * @see ModelElementFacade#getVisibility() 924 */ 925 public String getVisibility() 926 { 927 return this.getSuperFrontEndForward().getVisibility(); 928 } 929 930 /** 931 * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance 932 * is taken into account when searching for the stereotype), false otherwise. 933 * @see ModelElementFacade#hasExactStereotype(String stereotypeName) 934 */ 935 public boolean hasExactStereotype(String stereotypeName) 936 { 937 return this.getSuperFrontEndForward().hasExactStereotype(stereotypeName); 938 } 939 940 /** 941 * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma, 942 * pipe, semicolon, or << >> 943 * @see ModelElementFacade#hasKeyword(String keywordName) 944 */ 945 public boolean hasKeyword(String keywordName) 946 { 947 return this.getSuperFrontEndForward().hasKeyword(keywordName); 948 } 949 950 /** 951 * Returns true if the model element has the specified stereotype. If the stereotype itself 952 * does not match, then a search will be made up the stereotype inheritance hierarchy, and if 953 * one of the stereotype's ancestors has a matching name this method will return true, false 954 * otherwise. 955 * For example, if we have a certain stereotype called <<exception>> and a model element has a 956 * stereotype called <<applicationException>> which extends <<exception>>, when calling this 957 * method with 'stereotypeName' defined as 'exception' the method would return true since 958 * <<applicationException>> inherits from <<exception>>. If you want to check if the model 959 * element has the exact stereotype, then use the method 'hasExactStereotype' instead. 960 * @see ModelElementFacade#hasStereotype(String stereotypeName) 961 */ 962 public boolean hasStereotype(String stereotypeName) 963 { 964 return this.getSuperFrontEndForward().hasStereotype(stereotypeName); 965 } 966 967 /** 968 * True if there are target dependencies from this element that are instances of BindingFacade. 969 * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies. 970 * @see ModelElementFacade#isBindingDependenciesPresent() 971 */ 972 public boolean isBindingDependenciesPresent() 973 { 974 return this.getSuperFrontEndForward().isBindingDependenciesPresent(); 975 } 976 977 /** 978 * Indicates if any constraints are present on this model element. 979 * @see ModelElementFacade#isConstraintsPresent() 980 */ 981 public boolean isConstraintsPresent() 982 { 983 return this.getSuperFrontEndForward().isConstraintsPresent(); 984 } 985 986 /** 987 * Indicates if any documentation is present on this model element. 988 * @see ModelElementFacade#isDocumentationPresent() 989 */ 990 public boolean isDocumentationPresent() 991 { 992 return this.getSuperFrontEndForward().isDocumentationPresent(); 993 } 994 995 /** 996 * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript. 997 * @see ModelElementFacade#isReservedWord() 998 */ 999 public boolean isReservedWord() 1000 { 1001 return this.getSuperFrontEndForward().isReservedWord(); 1002 } 1003 1004 /** 1005 * True is there are template parameters on this model element. For UML2, applies to Class, 1006 * Operation, Property, and Parameter. 1007 * @see ModelElementFacade#isTemplateParametersPresent() 1008 */ 1009 public boolean isTemplateParametersPresent() 1010 { 1011 return this.getSuperFrontEndForward().isTemplateParametersPresent(); 1012 } 1013 1014 /** 1015 * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++, 1016 * JavaScript. Contains no spaces, special characters etc. Constraint always applied on 1017 * Enumerations and Interfaces, optionally applies on other model elements. 1018 * @see ModelElementFacade#isValidIdentifierName() 1019 */ 1020 public boolean isValidIdentifierName() 1021 { 1022 return this.getSuperFrontEndForward().isValidIdentifierName(); 1023 } 1024 1025 /** 1026 * Searches for the constraint with the specified 'name' on this model element, and if found 1027 * translates it using the specified 'translation' from a translation library discovered by the 1028 * framework. 1029 * @see ModelElementFacade#translateConstraint(String name, String translation) 1030 */ 1031 public String translateConstraint(String name, String translation) 1032 { 1033 return this.getSuperFrontEndForward().translateConstraint(name, translation); 1034 } 1035 1036 /** 1037 * Translates all constraints belonging to this model element with the given 'translation'. 1038 * @see ModelElementFacade#translateConstraints(String translation) 1039 */ 1040 public String[] translateConstraints(String translation) 1041 { 1042 return this.getSuperFrontEndForward().translateConstraints(translation); 1043 } 1044 1045 /** 1046 * Translates the constraints of the specified 'kind' belonging to this model element. 1047 * @see ModelElementFacade#translateConstraints(String kind, String translation) 1048 */ 1049 public String[] translateConstraints(String kind, String translation) 1050 { 1051 return this.getSuperFrontEndForward().translateConstraints(kind, translation); 1052 } 1053 1054 /** 1055 * An action is a named element that is the fundamental unit of executable functionality. The 1056 * execution 1057 * of an action represents some transformation or processing in the modeled system, be it a 1058 * computer 1059 * system or otherwise. An action represents a single step within an activity, that is, one that 1060 * is not 1061 * further decomposed within the activity. An action has pre- and post-conditions. 1062 * @see org.andromda.metafacades.uml.TransitionFacade#getEffect() 1063 */ 1064 public ActionFacade getEffect() 1065 { 1066 return this.getSuperFrontEndForward().getEffect(); 1067 } 1068 1069 /** 1070 * A representation of the model object 'Constraint'. A condition or restriction expressed in 1071 * natural 1072 * language text or in a machine readable language for the purpose of declaring some of the 1073 * semantics 1074 * of an element. 1075 * @see org.andromda.metafacades.uml.TransitionFacade#getGuard() 1076 */ 1077 public GuardFacade getGuard() 1078 { 1079 return this.getSuperFrontEndForward().getGuard(); 1080 } 1081 1082 /** 1083 * A representation of the model object 'Vertex'. An abstraction of a node in a state machine 1084 * graph. In 1085 * general, it can be the source or destination of any number of transitions. 1086 * @see org.andromda.metafacades.uml.TransitionFacade#getSource() 1087 */ 1088 public StateVertexFacade getSource() 1089 { 1090 return this.getSuperFrontEndForward().getSource(); 1091 } 1092 1093 /** 1094 * A representation of the model object 'Vertex'. An abstraction of a node in a state machine 1095 * graph. In 1096 * general, it can be the source or destination of any number of transitions. 1097 * @see org.andromda.metafacades.uml.TransitionFacade#getTarget() 1098 */ 1099 public StateVertexFacade getTarget() 1100 { 1101 return this.getSuperFrontEndForward().getTarget(); 1102 } 1103 1104 /** 1105 * If a trigger is present on this transition, this event represents that trigger. 1106 * @see org.andromda.metafacades.uml.TransitionFacade#getTrigger() 1107 */ 1108 public EventFacade getTrigger() 1109 { 1110 return this.getSuperFrontEndForward().getTrigger(); 1111 } 1112 1113 /** 1114 * TODO: Model Documentation for 1115 * org.andromda.metafacades.uml.TransitionFacade.enteringActionState 1116 * @see org.andromda.metafacades.uml.TransitionFacade#isEnteringActionState() 1117 */ 1118 public boolean isEnteringActionState() 1119 { 1120 return this.getSuperFrontEndForward().isEnteringActionState(); 1121 } 1122 1123 /** 1124 * TODO: Model Documentation for 1125 * org.andromda.metafacades.uml.TransitionFacade.enteringDecisionPoint 1126 * @see org.andromda.metafacades.uml.TransitionFacade#isEnteringDecisionPoint() 1127 */ 1128 public boolean isEnteringDecisionPoint() 1129 { 1130 return this.getSuperFrontEndForward().isEnteringDecisionPoint(); 1131 } 1132 1133 /** 1134 * TODO: Model Documentation for 1135 * org.andromda.metafacades.uml.TransitionFacade.enteringFinalState 1136 * @see org.andromda.metafacades.uml.TransitionFacade#isEnteringFinalState() 1137 */ 1138 public boolean isEnteringFinalState() 1139 { 1140 return this.getSuperFrontEndForward().isEnteringFinalState(); 1141 } 1142 1143 /** 1144 * TODO: Model Documentation for 1145 * org.andromda.metafacades.uml.TransitionFacade.exitingActionState 1146 * @see org.andromda.metafacades.uml.TransitionFacade#isExitingActionState() 1147 */ 1148 public boolean isExitingActionState() 1149 { 1150 return this.getSuperFrontEndForward().isExitingActionState(); 1151 } 1152 1153 /** 1154 * TODO: Model Documentation for 1155 * org.andromda.metafacades.uml.TransitionFacade.exitingDecisionPoint 1156 * @see org.andromda.metafacades.uml.TransitionFacade#isExitingDecisionPoint() 1157 */ 1158 public boolean isExitingDecisionPoint() 1159 { 1160 return this.getSuperFrontEndForward().isExitingDecisionPoint(); 1161 } 1162 1163 /** 1164 * TODO: Model Documentation for 1165 * org.andromda.metafacades.uml.TransitionFacade.exitingInitialState 1166 * @see org.andromda.metafacades.uml.TransitionFacade#isExitingInitialState() 1167 */ 1168 public boolean isExitingInitialState() 1169 { 1170 return this.getSuperFrontEndForward().isExitingInitialState(); 1171 } 1172 1173 /** 1174 * TODO: Model Documentation for org.andromda.metafacades.uml.TransitionFacade.triggerPresent 1175 * @see org.andromda.metafacades.uml.TransitionFacade#isTriggerPresent() 1176 */ 1177 public boolean isTriggerPresent() 1178 { 1179 return this.getSuperFrontEndForward().isTriggerPresent(); 1180 } 1181 1182 /** 1183 * @see MetafacadeBase#initialize() 1184 */ 1185 @Override 1186 public void initialize() 1187 { 1188 this.getSuperFrontEndForward().initialize(); 1189 } 1190 1191 /** 1192 * @return Object getSuperFrontEndForward().getValidationOwner() 1193 * @see MetafacadeBase#getValidationOwner() 1194 */ 1195 @Override 1196 public Object getValidationOwner() 1197 { 1198 Object owner = this.getSuperFrontEndForward().getValidationOwner(); 1199 return owner; 1200 } 1201 1202 /** 1203 * @return String getSuperFrontEndForward().getValidationName() 1204 * @see MetafacadeBase#getValidationName() 1205 */ 1206 @Override 1207 public String getValidationName() 1208 { 1209 String name = this.getSuperFrontEndForward().getValidationName(); 1210 return name; 1211 } 1212 1213 /** 1214 * <p><b>Constraint:</b> org::andromda::cartridges::bpm4struts::metafacades::StrutsForward::decision forwards need a controller operation with a non-void return type</p> 1215 * <p><b>Error:</b> If a transition is going into a decision point you will need to defer to an operation with a non-void return type. You will need to model this on the transition's trigger.</p> 1216 * <p><b>OCL:</b> context StrutsForward inv: enteringDecisionPoint implies (decisionTrigger->notEmpty() and operationCall->notEmpty() and operationCall.returnTypePresent)</p> 1217 * <p><b>Constraint:</b> org::andromda::cartridges::bpm4struts::metafacades::StrutsForward::decision outcome needs a guard</p> 1218 * <p><b>Error:</b> When a transition exits a decision point it needs a guard with a non-empty name.</p> 1219 * <p><b>OCL:</b> context StrutsForward inv: exitingDecisionPoint implies guardName->notEmpty()</p> 1220 * <p><b>Constraint:</b> org::andromda::cartridges::bpm4struts::metafacades::StrutsForward::validate decision points</p> 1221 * <p><b>Error:</b> Transitions carrying a controller call in their triggers need to target a decision point, this is a diamond shaped figure with 2 or more outgoing transitions.</p> 1222 * <p><b>OCL:</b> context StrutsForward inv: operationCall->notEmpty() and target.oclIsKindOf(org::andromda::metafacades::uml::PseudostateFacade) and (target.choice or target.junction) implies enteringDecisionPoint</p> 1223 * <p><b>Constraint:</b> org::andromda::cartridges::bpm4struts::metafacades::StrutsForward::operation calls must target a decision point</p> 1224 * <p><b>Error:</b> If you defer to an operation call on a transition, than that transition must target a decision point.</p> 1225 * <p><b>OCL:</b> context StrutsForward inv: operationCall->notEmpty() implies (target.oclIsKindOf(org::andromda::metafacades::uml::PseudostateFacade) and target.decisionPoint)</p> 1226 * @param validationMessages Collection<ModelValidationMessage> 1227 * @see MetafacadeBase#validateInvariants(Collection validationMessages) 1228 */ 1229 @Override 1230 public void validateInvariants(Collection<ModelValidationMessage> validationMessages) 1231 { 1232 this.getSuperFrontEndForward().validateInvariants(validationMessages); 1233 try 1234 { 1235 final Object contextElement = this.THIS(); 1236 boolean constraintValid = OCLResultEnsurer.ensure((Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"enteringDecisionPoint"))).booleanValue()?(OCLCollections.notEmpty(OCLIntrospector.invoke(contextElement,"decisionTrigger"))&&OCLCollections.notEmpty(OCLIntrospector.invoke(contextElement,"operationCall"))&&Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"operationCall.returnTypePresent"))).booleanValue()):true)); 1237 if (!constraintValid) 1238 { 1239 validationMessages.add( 1240 new ModelValidationMessage( 1241 (MetafacadeBase)contextElement , 1242 "org::andromda::cartridges::bpm4struts::metafacades::StrutsForward::decision forwards need a controller operation with a non-void return type", 1243 "If a transition is going into a decision point you will need to defer to an operation with a non-void return type. You will need to model this on the transition's trigger.")); 1244 } 1245 } 1246 catch (Throwable th) 1247 { 1248 Throwable cause = th.getCause(); 1249 int depth = 0; // Some throwables have infinite recursion 1250 while (cause != null && depth < 7) 1251 { 1252 th = cause; 1253 depth++; 1254 } 1255 logger.error("Error validating constraint 'org::andromda::cartridges::bpm4struts::metafacades::StrutsForward::decision forwards need a controller operation with a non-void return type' ON " 1256 + this.THIS().toString() + ": " + th.getMessage(), th); 1257 } 1258 try 1259 { 1260 final Object contextElement = this.THIS(); 1261 boolean constraintValid = OCLResultEnsurer.ensure((Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"exitingDecisionPoint"))).booleanValue()?OCLCollections.notEmpty(OCLIntrospector.invoke(contextElement,"guardName")):true)); 1262 if (!constraintValid) 1263 { 1264 validationMessages.add( 1265 new ModelValidationMessage( 1266 (MetafacadeBase)contextElement , 1267 "org::andromda::cartridges::bpm4struts::metafacades::StrutsForward::decision outcome needs a guard", 1268 "When a transition exits a decision point it needs a guard with a non-empty name.")); 1269 } 1270 } 1271 catch (Throwable th) 1272 { 1273 Throwable cause = th.getCause(); 1274 int depth = 0; // Some throwables have infinite recursion 1275 while (cause != null && depth < 7) 1276 { 1277 th = cause; 1278 depth++; 1279 } 1280 logger.error("Error validating constraint 'org::andromda::cartridges::bpm4struts::metafacades::StrutsForward::decision outcome needs a guard' ON " 1281 + this.THIS().toString() + ": " + th.getMessage(), th); 1282 } 1283 try 1284 { 1285 final Object contextElement = this.THIS(); 1286 boolean constraintValid = OCLResultEnsurer.ensure((Boolean.valueOf(String.valueOf(OCLCollections.notEmpty(OCLIntrospector.invoke(contextElement,"operationCall"))&&OCLIntrospector.invoke(contextElement,"target") instanceof PseudostateFacade&&(Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"target.choice"))).booleanValue()||Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"target.junction"))).booleanValue()))).booleanValue()?Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"enteringDecisionPoint"))).booleanValue():true)); 1287 if (!constraintValid) 1288 { 1289 validationMessages.add( 1290 new ModelValidationMessage( 1291 (MetafacadeBase)contextElement , 1292 "org::andromda::cartridges::bpm4struts::metafacades::StrutsForward::validate decision points", 1293 "Transitions carrying a controller call in their triggers need to target a decision point, this is a diamond shaped figure with 2 or more outgoing transitions.")); 1294 } 1295 } 1296 catch (Throwable th) 1297 { 1298 Throwable cause = th.getCause(); 1299 int depth = 0; // Some throwables have infinite recursion 1300 while (cause != null && depth < 7) 1301 { 1302 th = cause; 1303 depth++; 1304 } 1305 logger.error("Error validating constraint 'org::andromda::cartridges::bpm4struts::metafacades::StrutsForward::validate decision points' ON " 1306 + this.THIS().toString() + ": " + th.getMessage(), th); 1307 } 1308 try 1309 { 1310 final Object contextElement = this.THIS(); 1311 boolean constraintValid = OCLResultEnsurer.ensure((Boolean.valueOf(String.valueOf(OCLCollections.notEmpty(OCLIntrospector.invoke(contextElement,"operationCall")))).booleanValue()?(OCLIntrospector.invoke(contextElement,"target") instanceof PseudostateFacade&&Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"target.decisionPoint"))).booleanValue()):true)); 1312 if (!constraintValid) 1313 { 1314 validationMessages.add( 1315 new ModelValidationMessage( 1316 (MetafacadeBase)contextElement , 1317 "org::andromda::cartridges::bpm4struts::metafacades::StrutsForward::operation calls must target a decision point", 1318 "If you defer to an operation call on a transition, than that transition must target a decision point.")); 1319 } 1320 } 1321 catch (Throwable th) 1322 { 1323 Throwable cause = th.getCause(); 1324 int depth = 0; // Some throwables have infinite recursion 1325 while (cause != null && depth < 7) 1326 { 1327 th = cause; 1328 depth++; 1329 } 1330 logger.error("Error validating constraint 'org::andromda::cartridges::bpm4struts::metafacades::StrutsForward::operation calls must target a decision point' ON " 1331 + this.THIS().toString() + ": " + th.getMessage(), th); 1332 } 1333 } 1334 1335 /** 1336 * The property that stores the name of the metafacade. 1337 */ 1338 private static final String NAME_PROPERTY = "name"; 1339 private static final String FQNAME_PROPERTY = "fullyQualifiedName"; 1340 1341 /** 1342 * @see Object#toString() 1343 */ 1344 @Override 1345 public String toString() 1346 { 1347 final StringBuilder toString = new StringBuilder(this.getClass().getName()); 1348 toString.append("["); 1349 try 1350 { 1351 toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY)); 1352 } 1353 catch (final Throwable tryAgain) 1354 { 1355 try 1356 { 1357 toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY)); 1358 } 1359 catch (final Throwable ignore) 1360 { 1361 // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property 1362 } 1363 } 1364 toString.append("]"); 1365 return toString.toString(); 1366 } 1367}