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