View Javadoc
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 }