1 // license-header java merge-point
2 //
3 // Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
4 //
5 package org.andromda.cartridges.bpm4struts.metafacades;
6
7 import java.util.Collection;
8 import java.util.List;
9 import java.util.Map;
10 import org.andromda.core.common.Introspector;
11 import org.andromda.core.metafacade.MetafacadeBase;
12 import org.andromda.core.metafacade.MetafacadeFactory;
13 import org.andromda.core.metafacade.ModelValidationMessage;
14 import org.andromda.metafacades.uml.ActionFacade;
15 import org.andromda.metafacades.uml.ConstraintFacade;
16 import org.andromda.metafacades.uml.DependencyFacade;
17 import org.andromda.metafacades.uml.EventFacade;
18 import org.andromda.metafacades.uml.FrontEndAction;
19 import org.andromda.metafacades.uml.FrontEndActivityGraph;
20 import org.andromda.metafacades.uml.FrontEndControllerOperation;
21 import org.andromda.metafacades.uml.FrontEndEvent;
22 import org.andromda.metafacades.uml.FrontEndForward;
23 import org.andromda.metafacades.uml.FrontEndParameter;
24 import org.andromda.metafacades.uml.FrontEndUseCase;
25 import org.andromda.metafacades.uml.GuardFacade;
26 import org.andromda.metafacades.uml.ModelElementFacade;
27 import org.andromda.metafacades.uml.ModelFacade;
28 import org.andromda.metafacades.uml.PackageFacade;
29 import org.andromda.metafacades.uml.PseudostateFacade;
30 import org.andromda.metafacades.uml.StateMachineFacade;
31 import org.andromda.metafacades.uml.StateVertexFacade;
32 import org.andromda.metafacades.uml.StereotypeFacade;
33 import org.andromda.metafacades.uml.TaggedValueFacade;
34 import org.andromda.metafacades.uml.TemplateParameterFacade;
35 import org.andromda.metafacades.uml.TypeMappings;
36 import org.andromda.translation.ocl.validation.OCLCollections;
37 import org.andromda.translation.ocl.validation.OCLIntrospector;
38 import org.andromda.translation.ocl.validation.OCLResultEnsurer;
39 import org.apache.log4j.Logger;
40
41 /**
42 * A Struts forward is any transition between states. Some of these forwards may end up as actual
43 * forwards in the Struts deployment descriptor.
44 * MetafacadeLogic for StrutsForward
45 *
46 * @see StrutsForward
47 */
48 public abstract class StrutsForwardLogic
49 extends MetafacadeBase
50 implements StrutsForward
51 {
52 /**
53 * The underlying UML object
54 * @see Object
55 */
56 protected Object metaObject;
57
58 /** Create Metafacade implementation instance using the MetafacadeFactory from the context
59 * @param metaObjectIn
60 * @param context
61 */
62 protected StrutsForwardLogic(Object metaObjectIn, String context)
63 {
64 super(metaObjectIn, getContext(context));
65 this.superFrontEndForward =
66 (FrontEndForward)
67 MetafacadeFactory.getInstance().createFacadeImpl(
68 "org.andromda.metafacades.uml.FrontEndForward",
69 metaObjectIn,
70 getContext(context));
71 this.metaObject = metaObjectIn;
72 }
73
74 /**
75 * The logger instance.
76 */
77 private static final Logger logger = Logger.getLogger(StrutsForwardLogic.class);
78
79 /**
80 * Gets the context for this metafacade logic instance.
81 * @param context String. Set to StrutsForward if null
82 * @return context String
83 */
84 private static String getContext(String context)
85 {
86 if (context == null)
87 {
88 context = "org.andromda.cartridges.bpm4struts.metafacades.StrutsForward";
89 }
90 return context;
91 }
92
93 private FrontEndForward superFrontEndForward;
94 private boolean superFrontEndForwardInitialized = false;
95
96 /**
97 * Gets the FrontEndForward parent instance.
98 * @return this.superFrontEndForward FrontEndForward
99 */
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 }