Source code

001// license-header java merge-point
002//
003// Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
004//
005package org.andromda.cartridges.jsf.metafacades;
006
007import java.util.Collection;
008import java.util.List;
009import org.andromda.core.common.Introspector;
010import org.andromda.core.metafacade.MetafacadeBase;
011import org.andromda.core.metafacade.MetafacadeFactory;
012import org.andromda.core.metafacade.ModelValidationMessage;
013import org.andromda.metafacades.uml.ActionFacade;
014import org.andromda.metafacades.uml.ConstraintFacade;
015import org.andromda.metafacades.uml.DependencyFacade;
016import org.andromda.metafacades.uml.EventFacade;
017import org.andromda.metafacades.uml.FrontEndAction;
018import org.andromda.metafacades.uml.FrontEndExceptionHandler;
019import org.andromda.metafacades.uml.FrontEndForward;
020import org.andromda.metafacades.uml.FrontEndParameter;
021import org.andromda.metafacades.uml.FrontEndUseCase;
022import org.andromda.metafacades.uml.FrontEndView;
023import org.andromda.metafacades.uml.ModelElementFacade;
024import org.andromda.metafacades.uml.ModelFacade;
025import org.andromda.metafacades.uml.OperationFacade;
026import org.andromda.metafacades.uml.PackageFacade;
027import org.andromda.metafacades.uml.PartitionFacade;
028import org.andromda.metafacades.uml.StateFacade;
029import org.andromda.metafacades.uml.StateMachineFacade;
030import org.andromda.metafacades.uml.StereotypeFacade;
031import org.andromda.metafacades.uml.TaggedValueFacade;
032import org.andromda.metafacades.uml.TemplateParameterFacade;
033import org.andromda.metafacades.uml.TransitionFacade;
034import org.andromda.metafacades.uml.TypeMappings;
035import org.andromda.translation.ocl.validation.OCLCollections;
036import org.andromda.translation.ocl.validation.OCLIntrospector;
037import org.andromda.translation.ocl.validation.OCLResultEnsurer;
038import org.apache.commons.collections.Transformer;
039import org.apache.log4j.Logger;
040
041/**
042 * Represents a JSF view for a front-end application.
043 * MetafacadeLogic for JSFView
044 *
045 * @see JSFView
046 */
047public abstract class JSFViewLogic
048    extends MetafacadeBase
049    implements JSFView
050{
051    /**
052     * The underlying UML object
053     * @see Object
054     */
055    protected Object metaObject;
056
057    /** Create Metafacade implementation instance using the MetafacadeFactory from the context
058     * @param metaObjectIn
059     * @param context
060     */
061    protected JSFViewLogic(Object metaObjectIn, String context)
062    {
063        super(metaObjectIn, getContext(context));
064        this.superFrontEndView =
065           (FrontEndView)
066            MetafacadeFactory.getInstance().createFacadeImpl(
067                    "org.andromda.metafacades.uml.FrontEndView",
068                    metaObjectIn,
069                    getContext(context));
070        this.metaObject = metaObjectIn;
071    }
072
073    /**
074     * The logger instance.
075     */
076    private static final Logger logger = Logger.getLogger(JSFViewLogic.class);
077
078    /**
079     * Gets the context for this metafacade logic instance.
080     * @param context String. Set to JSFView if null
081     * @return context String
082     */
083    private static String getContext(String context)
084    {
085        if (context == null)
086        {
087            context = "org.andromda.cartridges.jsf.metafacades.JSFView";
088        }
089        return context;
090    }
091
092    private FrontEndView superFrontEndView;
093    private boolean superFrontEndViewInitialized = false;
094
095    /**
096     * Gets the FrontEndView parent instance.
097     * @return this.superFrontEndView FrontEndView
098     */
099    private FrontEndView getSuperFrontEndView()
100    {
101        if (!this.superFrontEndViewInitialized)
102        {
103            ((MetafacadeBase)this.superFrontEndView).setMetafacadeContext(this.getMetafacadeContext());
104            this.superFrontEndViewInitialized = true;
105        }
106        return this.superFrontEndView;
107    }
108
109    /** Reset context only for non-root metafacades
110     * @param context
111     * @see MetafacadeBase#resetMetafacadeContext(String context)
112     */
113    @Override
114    public void resetMetafacadeContext(String context)
115    {
116        if (!this.contextRoot) // reset context only for non-root metafacades
117        {
118            context = getContext(context);  // to have same value as in original constructor call
119            setMetafacadeContext (context);
120            if (this.superFrontEndViewInitialized)
121            {
122                ((MetafacadeBase)this.superFrontEndView).resetMetafacadeContext(context);
123            }
124        }
125    }
126
127    /**
128     * @return boolean true always
129     * @see JSFView
130     */
131    public boolean isJSFViewMetaType()
132    {
133        return true;
134    }
135
136    // --------------- attributes ---------------------
137
138   /**
139    * @see org.andromda.cartridges.jsf.metafacades.JSFView#getPath()
140    * @return String
141    */
142    protected abstract String handleGetPath();
143
144    private String __path1a;
145    private boolean __path1aSet = false;
146
147    /**
148     * The full path of the view resources (i.e. the JSP page).
149     * @return (String)handleGetPath()
150     */
151    public final String getPath()
152    {
153        String path1a = this.__path1a;
154        if (!this.__path1aSet)
155        {
156            // path has no pre constraints
157            path1a = handleGetPath();
158            // path has no post constraints
159            this.__path1a = path1a;
160            if (isMetafacadePropertyCachingEnabled())
161            {
162                this.__path1aSet = true;
163            }
164        }
165        return path1a;
166    }
167
168   /**
169    * @see org.andromda.cartridges.jsf.metafacades.JSFView#getTitleKey()
170    * @return String
171    */
172    protected abstract String handleGetTitleKey();
173
174    private String __titleKey2a;
175    private boolean __titleKey2aSet = false;
176
177    /**
178     * A resource message key suited for the view's title.
179     * @return (String)handleGetTitleKey()
180     */
181    public final String getTitleKey()
182    {
183        String titleKey2a = this.__titleKey2a;
184        if (!this.__titleKey2aSet)
185        {
186            // titleKey has no pre constraints
187            titleKey2a = handleGetTitleKey();
188            // titleKey has no post constraints
189            this.__titleKey2a = titleKey2a;
190            if (isMetafacadePropertyCachingEnabled())
191            {
192                this.__titleKey2aSet = true;
193            }
194        }
195        return titleKey2a;
196    }
197
198   /**
199    * @see org.andromda.cartridges.jsf.metafacades.JSFView#getTitleValue()
200    * @return String
201    */
202    protected abstract String handleGetTitleValue();
203
204    private String __titleValue3a;
205    private boolean __titleValue3aSet = false;
206
207    /**
208     * A default resource message value suited for the page's title.
209     * @return (String)handleGetTitleValue()
210     */
211    public final String getTitleValue()
212    {
213        String titleValue3a = this.__titleValue3a;
214        if (!this.__titleValue3aSet)
215        {
216            // titleValue has no pre constraints
217            titleValue3a = handleGetTitleValue();
218            // titleValue has no post constraints
219            this.__titleValue3a = titleValue3a;
220            if (isMetafacadePropertyCachingEnabled())
221            {
222                this.__titleValue3aSet = true;
223            }
224        }
225        return titleValue3a;
226    }
227
228   /**
229    * @see org.andromda.cartridges.jsf.metafacades.JSFView#getMessageKey()
230    * @return String
231    */
232    protected abstract String handleGetMessageKey();
233
234    private String __messageKey4a;
235    private boolean __messageKey4aSet = false;
236
237    /**
238     * The default resource message key for this view.
239     * @return (String)handleGetMessageKey()
240     */
241    public final String getMessageKey()
242    {
243        String messageKey4a = this.__messageKey4a;
244        if (!this.__messageKey4aSet)
245        {
246            // messageKey has no pre constraints
247            messageKey4a = handleGetMessageKey();
248            // messageKey has no post constraints
249            this.__messageKey4a = messageKey4a;
250            if (isMetafacadePropertyCachingEnabled())
251            {
252                this.__messageKey4aSet = true;
253            }
254        }
255        return messageKey4a;
256    }
257
258   /**
259    * @see org.andromda.cartridges.jsf.metafacades.JSFView#getDocumentationKey()
260    * @return String
261    */
262    protected abstract String handleGetDocumentationKey();
263
264    private String __documentationKey5a;
265    private boolean __documentationKey5aSet = false;
266
267    /**
268     * A resource message key suited for the page's documentation.
269     * @return (String)handleGetDocumentationKey()
270     */
271    public final String getDocumentationKey()
272    {
273        String documentationKey5a = this.__documentationKey5a;
274        if (!this.__documentationKey5aSet)
275        {
276            // documentationKey has no pre constraints
277            documentationKey5a = handleGetDocumentationKey();
278            // documentationKey has no post constraints
279            this.__documentationKey5a = documentationKey5a;
280            if (isMetafacadePropertyCachingEnabled())
281            {
282                this.__documentationKey5aSet = true;
283            }
284        }
285        return documentationKey5a;
286    }
287
288   /**
289    * @see org.andromda.cartridges.jsf.metafacades.JSFView#getDocumentationValue()
290    * @return String
291    */
292    protected abstract String handleGetDocumentationValue();
293
294    private String __documentationValue6a;
295    private boolean __documentationValue6aSet = false;
296
297    /**
298     * A resource message value suited for the view's documentation.
299     * @return (String)handleGetDocumentationValue()
300     */
301    public final String getDocumentationValue()
302    {
303        String documentationValue6a = this.__documentationValue6a;
304        if (!this.__documentationValue6aSet)
305        {
306            // documentationValue has no pre constraints
307            documentationValue6a = handleGetDocumentationValue();
308            // documentationValue has no post constraints
309            this.__documentationValue6a = documentationValue6a;
310            if (isMetafacadePropertyCachingEnabled())
311            {
312                this.__documentationValue6aSet = true;
313            }
314        }
315        return documentationValue6a;
316    }
317
318   /**
319    * @see org.andromda.cartridges.jsf.metafacades.JSFView#getMessageValue()
320    * @return String
321    */
322    protected abstract String handleGetMessageValue();
323
324    private String __messageValue7a;
325    private boolean __messageValue7aSet = false;
326
327    /**
328     * A displayable version of this view's name.
329     * @return (String)handleGetMessageValue()
330     */
331    public final String getMessageValue()
332    {
333        String messageValue7a = this.__messageValue7a;
334        if (!this.__messageValue7aSet)
335        {
336            // messageValue has no pre constraints
337            messageValue7a = handleGetMessageValue();
338            // messageValue has no post constraints
339            this.__messageValue7a = messageValue7a;
340            if (isMetafacadePropertyCachingEnabled())
341            {
342                this.__messageValue7aSet = true;
343            }
344        }
345        return messageValue7a;
346    }
347
348   /**
349    * @see org.andromda.cartridges.jsf.metafacades.JSFView#getFullyQualifiedPopulator()
350    * @return String
351    */
352    protected abstract String handleGetFullyQualifiedPopulator();
353
354    private String __fullyQualifiedPopulator8a;
355    private boolean __fullyQualifiedPopulator8aSet = false;
356
357    /**
358     * The fully qualified name of this view's form populator.
359     * @return (String)handleGetFullyQualifiedPopulator()
360     */
361    public final String getFullyQualifiedPopulator()
362    {
363        String fullyQualifiedPopulator8a = this.__fullyQualifiedPopulator8a;
364        if (!this.__fullyQualifiedPopulator8aSet)
365        {
366            // fullyQualifiedPopulator has no pre constraints
367            fullyQualifiedPopulator8a = handleGetFullyQualifiedPopulator();
368            // fullyQualifiedPopulator has no post constraints
369            this.__fullyQualifiedPopulator8a = fullyQualifiedPopulator8a;
370            if (isMetafacadePropertyCachingEnabled())
371            {
372                this.__fullyQualifiedPopulator8aSet = true;
373            }
374        }
375        return fullyQualifiedPopulator8a;
376    }
377
378   /**
379    * @see org.andromda.cartridges.jsf.metafacades.JSFView#getPopulator()
380    * @return String
381    */
382    protected abstract String handleGetPopulator();
383
384    private String __populator9a;
385    private boolean __populator9aSet = false;
386
387    /**
388     * The name of the form populator for this view.
389     * @return (String)handleGetPopulator()
390     */
391    public final String getPopulator()
392    {
393        String populator9a = this.__populator9a;
394        if (!this.__populator9aSet)
395        {
396            // populator has no pre constraints
397            populator9a = handleGetPopulator();
398            // populator has no post constraints
399            this.__populator9a = populator9a;
400            if (isMetafacadePropertyCachingEnabled())
401            {
402                this.__populator9aSet = true;
403            }
404        }
405        return populator9a;
406    }
407
408   /**
409    * @see org.andromda.cartridges.jsf.metafacades.JSFView#getPopulatorPath()
410    * @return String
411    */
412    protected abstract String handleGetPopulatorPath();
413
414    private String __populatorPath10a;
415    private boolean __populatorPath10aSet = false;
416
417    /**
418     * The path to the form populator.
419     * @return (String)handleGetPopulatorPath()
420     */
421    public final String getPopulatorPath()
422    {
423        String populatorPath10a = this.__populatorPath10a;
424        if (!this.__populatorPath10aSet)
425        {
426            // populatorPath has no pre constraints
427            populatorPath10a = handleGetPopulatorPath();
428            // populatorPath has no post constraints
429            this.__populatorPath10a = populatorPath10a;
430            if (isMetafacadePropertyCachingEnabled())
431            {
432                this.__populatorPath10aSet = true;
433            }
434        }
435        return populatorPath10a;
436    }
437
438   /**
439    * @see org.andromda.cartridges.jsf.metafacades.JSFView#isPopulatorRequired()
440    * @return boolean
441    */
442    protected abstract boolean handleIsPopulatorRequired();
443
444    private boolean __populatorRequired11a;
445    private boolean __populatorRequired11aSet = false;
446
447    /**
448     * Indicates if a populator is required for this view.
449     * @return (boolean)handleIsPopulatorRequired()
450     */
451    public final boolean isPopulatorRequired()
452    {
453        boolean populatorRequired11a = this.__populatorRequired11a;
454        if (!this.__populatorRequired11aSet)
455        {
456            // populatorRequired has no pre constraints
457            populatorRequired11a = handleIsPopulatorRequired();
458            // populatorRequired has no post constraints
459            this.__populatorRequired11a = populatorRequired11a;
460            if (isMetafacadePropertyCachingEnabled())
461            {
462                this.__populatorRequired11aSet = true;
463            }
464        }
465        return populatorRequired11a;
466    }
467
468   /**
469    * @see org.andromda.cartridges.jsf.metafacades.JSFView#isValidationRequired()
470    * @return boolean
471    */
472    protected abstract boolean handleIsValidationRequired();
473
474    private boolean __validationRequired12a;
475    private boolean __validationRequired12aSet = false;
476
477    /**
478     * Indicates whether or not at least one parameter of an outgoing action in this view requires
479     * validation.
480     * @return (boolean)handleIsValidationRequired()
481     */
482    public final boolean isValidationRequired()
483    {
484        boolean validationRequired12a = this.__validationRequired12a;
485        if (!this.__validationRequired12aSet)
486        {
487            // validationRequired has no pre constraints
488            validationRequired12a = handleIsValidationRequired();
489            // validationRequired has no post constraints
490            this.__validationRequired12a = validationRequired12a;
491            if (isMetafacadePropertyCachingEnabled())
492            {
493                this.__validationRequired12aSet = true;
494            }
495        }
496        return validationRequired12a;
497    }
498
499   /**
500    * @see org.andromda.cartridges.jsf.metafacades.JSFView#isPopup()
501    * @return boolean
502    */
503    protected abstract boolean handleIsPopup();
504
505    private boolean __popup13a;
506    private boolean __popup13aSet = false;
507
508    /**
509     * Indicates if this view represents a popup.
510     * @return (boolean)handleIsPopup()
511     */
512    public final boolean isPopup()
513    {
514        boolean popup13a = this.__popup13a;
515        if (!this.__popup13aSet)
516        {
517            // popup has no pre constraints
518            popup13a = handleIsPopup();
519            // popup has no post constraints
520            this.__popup13a = popup13a;
521            if (isMetafacadePropertyCachingEnabled())
522            {
523                this.__popup13aSet = true;
524            }
525        }
526        return popup13a;
527    }
528
529   /**
530    * @see org.andromda.cartridges.jsf.metafacades.JSFView#isNonTableVariablesPresent()
531    * @return boolean
532    */
533    protected abstract boolean handleIsNonTableVariablesPresent();
534
535    private boolean __nonTableVariablesPresent14a;
536    private boolean __nonTableVariablesPresent14aSet = false;
537
538    /**
539     * Indicates whether or not any non-table view variables are present in this view.
540     * @return (boolean)handleIsNonTableVariablesPresent()
541     */
542    public final boolean isNonTableVariablesPresent()
543    {
544        boolean nonTableVariablesPresent14a = this.__nonTableVariablesPresent14a;
545        if (!this.__nonTableVariablesPresent14aSet)
546        {
547            // nonTableVariablesPresent has no pre constraints
548            nonTableVariablesPresent14a = handleIsNonTableVariablesPresent();
549            // nonTableVariablesPresent has no post constraints
550            this.__nonTableVariablesPresent14a = nonTableVariablesPresent14a;
551            if (isMetafacadePropertyCachingEnabled())
552            {
553                this.__nonTableVariablesPresent14aSet = true;
554            }
555        }
556        return nonTableVariablesPresent14a;
557    }
558
559   /**
560    * @see org.andromda.cartridges.jsf.metafacades.JSFView#isHasNameOfUseCase()
561    * @return boolean
562    */
563    protected abstract boolean handleIsHasNameOfUseCase();
564
565    private boolean __hasNameOfUseCase15a;
566    private boolean __hasNameOfUseCase15aSet = false;
567
568    /**
569     * Indicates whether or not this view has the same name as the use case in which it is
570     * contained.
571     * @return (boolean)handleIsHasNameOfUseCase()
572     */
573    public final boolean isHasNameOfUseCase()
574    {
575        boolean hasNameOfUseCase15a = this.__hasNameOfUseCase15a;
576        if (!this.__hasNameOfUseCase15aSet)
577        {
578            // hasNameOfUseCase has no pre constraints
579            hasNameOfUseCase15a = handleIsHasNameOfUseCase();
580            // hasNameOfUseCase has no post constraints
581            this.__hasNameOfUseCase15a = hasNameOfUseCase15a;
582            if (isMetafacadePropertyCachingEnabled())
583            {
584                this.__hasNameOfUseCase15aSet = true;
585            }
586        }
587        return hasNameOfUseCase15a;
588    }
589
590   /**
591    * @see org.andromda.cartridges.jsf.metafacades.JSFView#getFormKey()
592    * @return String
593    */
594    protected abstract String handleGetFormKey();
595
596    private String __formKey16a;
597    private boolean __formKey16aSet = false;
598
599    /**
600     * The key that stores the form in which information is passed from one action to another.
601     * @return (String)handleGetFormKey()
602     */
603    public final String getFormKey()
604    {
605        String formKey16a = this.__formKey16a;
606        if (!this.__formKey16aSet)
607        {
608            // formKey has no pre constraints
609            formKey16a = handleGetFormKey();
610            // formKey has no post constraints
611            this.__formKey16a = formKey16a;
612            if (isMetafacadePropertyCachingEnabled())
613            {
614                this.__formKey16aSet = true;
615            }
616        }
617        return formKey16a;
618    }
619
620   /**
621    * @see org.andromda.cartridges.jsf.metafacades.JSFView#getFromOutcome()
622    * @return String
623    */
624    protected abstract String handleGetFromOutcome();
625
626    private String __fromOutcome17a;
627    private boolean __fromOutcome17aSet = false;
628
629    /**
630     * The name that corresponds to the from-outcome in an navigational rule.
631     * @return (String)handleGetFromOutcome()
632     */
633    public final String getFromOutcome()
634    {
635        String fromOutcome17a = this.__fromOutcome17a;
636        if (!this.__fromOutcome17aSet)
637        {
638            // fromOutcome has no pre constraints
639            fromOutcome17a = handleGetFromOutcome();
640            // fromOutcome has no post constraints
641            this.__fromOutcome17a = fromOutcome17a;
642            if (isMetafacadePropertyCachingEnabled())
643            {
644                this.__fromOutcome17aSet = true;
645            }
646        }
647        return fromOutcome17a;
648    }
649
650   /**
651    * @see org.andromda.cartridges.jsf.metafacades.JSFView#isNeedsFileUpload()
652    * @return boolean
653    */
654    protected abstract boolean handleIsNeedsFileUpload();
655
656    private boolean __needsFileUpload18a;
657    private boolean __needsFileUpload18aSet = false;
658
659    /**
660     * TODO: Model Documentation for org.andromda.cartridges.jsf.metafacades.JSFView.needsFileUpload
661     * @return (boolean)handleIsNeedsFileUpload()
662     */
663    public final boolean isNeedsFileUpload()
664    {
665        boolean needsFileUpload18a = this.__needsFileUpload18a;
666        if (!this.__needsFileUpload18aSet)
667        {
668            // needsFileUpload has no pre constraints
669            needsFileUpload18a = handleIsNeedsFileUpload();
670            // needsFileUpload has no post constraints
671            this.__needsFileUpload18a = needsFileUpload18a;
672            if (isMetafacadePropertyCachingEnabled())
673            {
674                this.__needsFileUpload18aSet = true;
675            }
676        }
677        return needsFileUpload18a;
678    }
679
680    // ------------- associations ------------------
681
682    private List<JSFForward> __getForwards1r;
683    private boolean __getForwards1rSet = false;
684
685    /**
686     * Represents a JSF view for a front-end application.
687     * @return (List<JSFForward>)handleGetForwards()
688     */
689    public final List<JSFForward> getForwards()
690    {
691        List<JSFForward> getForwards1r = this.__getForwards1r;
692        if (!this.__getForwards1rSet)
693        {
694            // jSFView has no pre constraints
695            List result = handleGetForwards();
696            List shieldedResult = this.shieldedElements(result);
697            try
698            {
699                getForwards1r = (List<JSFForward>)shieldedResult;
700            }
701            catch (ClassCastException ex)
702            {
703                // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
704                JSFViewLogic.logger.warn("incorrect metafacade cast for JSFViewLogic.getForwards List<JSFForward> " + result + ": " + shieldedResult);
705            }
706            // jSFView has no post constraints
707            this.__getForwards1r = getForwards1r;
708            if (isMetafacadePropertyCachingEnabled())
709            {
710                this.__getForwards1rSet = true;
711            }
712        }
713        return getForwards1r;
714    }
715
716    /**
717     * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
718     * @return  List
719     */
720    protected abstract List handleGetForwards();
721
722    /**
723     * Represents a JSF view for a front-end application.
724     * @return (List<JSFParameter>)handleGetBackingValueVariables()
725     */
726    public final List<JSFParameter> getBackingValueVariables()
727    {
728        List<JSFParameter> getBackingValueVariables2r = null;
729        // jSFView has no pre constraints
730        List result = handleGetBackingValueVariables();
731        List shieldedResult = this.shieldedElements(result);
732        try
733        {
734            getBackingValueVariables2r = (List<JSFParameter>)shieldedResult;
735        }
736        catch (ClassCastException ex)
737        {
738            // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
739            JSFViewLogic.logger.warn("incorrect metafacade cast for JSFViewLogic.getBackingValueVariables List<JSFParameter> " + result + ": " + shieldedResult);
740        }
741        // jSFView has no post constraints
742        return getBackingValueVariables2r;
743    }
744
745    /**
746     * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
747     * @return  List
748     */
749    protected abstract List handleGetBackingValueVariables();
750
751    private List<JSFAction> __getFormActions3r;
752    private boolean __getFormActions3rSet = false;
753
754    /**
755     * Represents a JSF view for a front-end application.
756     * @return (List<JSFAction>)handleGetFormActions()
757     */
758    public final List<JSFAction> getFormActions()
759    {
760        List<JSFAction> getFormActions3r = this.__getFormActions3r;
761        if (!this.__getFormActions3rSet)
762        {
763            // jSFView has no pre constraints
764            List result = handleGetFormActions();
765            List shieldedResult = this.shieldedElements(result);
766            try
767            {
768                getFormActions3r = (List<JSFAction>)shieldedResult;
769            }
770            catch (ClassCastException ex)
771            {
772                // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
773                JSFViewLogic.logger.warn("incorrect metafacade cast for JSFViewLogic.getFormActions List<JSFAction> " + result + ": " + shieldedResult);
774            }
775            // jSFView has no post constraints
776            this.__getFormActions3r = getFormActions3r;
777            if (isMetafacadePropertyCachingEnabled())
778            {
779                this.__getFormActions3rSet = true;
780            }
781        }
782        return getFormActions3r;
783    }
784
785    /**
786     * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
787     * @return  List
788     */
789    protected abstract List handleGetFormActions();
790
791    private List<JSFAction> __getActionForwards4r;
792    private boolean __getActionForwards4rSet = false;
793
794    /**
795     * Represents a JSF view for a front-end application.
796     * @return (List<JSFAction>)handleGetActionForwards()
797     */
798    public final List<JSFAction> getActionForwards()
799    {
800        List<JSFAction> getActionForwards4r = this.__getActionForwards4r;
801        if (!this.__getActionForwards4rSet)
802        {
803            // jSFView has no pre constraints
804            List result = handleGetActionForwards();
805            List shieldedResult = this.shieldedElements(result);
806            try
807            {
808                getActionForwards4r = (List<JSFAction>)shieldedResult;
809            }
810            catch (ClassCastException ex)
811            {
812                // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
813                JSFViewLogic.logger.warn("incorrect metafacade cast for JSFViewLogic.getActionForwards List<JSFAction> " + result + ": " + shieldedResult);
814            }
815            // jSFView has no post constraints
816            this.__getActionForwards4r = getActionForwards4r;
817            if (isMetafacadePropertyCachingEnabled())
818            {
819                this.__getActionForwards4rSet = true;
820            }
821        }
822        return getActionForwards4r;
823    }
824
825    /**
826     * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
827     * @return  List
828     */
829    protected abstract List handleGetActionForwards();
830
831    /**
832     * @return true
833     * @see FrontEndView
834     */
835    public boolean isFrontEndViewMetaType()
836    {
837        return true;
838    }
839
840    /**
841     * @return true
842     * @see org.andromda.metafacades.uml.FrontEndActionState
843     */
844    public boolean isFrontEndActionStateMetaType()
845    {
846        return true;
847    }
848
849    /**
850     * @return true
851     * @see org.andromda.metafacades.uml.ActionStateFacade
852     */
853    public boolean isActionStateFacadeMetaType()
854    {
855        return true;
856    }
857
858    /**
859     * @return true
860     * @see StateFacade
861     */
862    public boolean isStateFacadeMetaType()
863    {
864        return true;
865    }
866
867    /**
868     * @return true
869     * @see org.andromda.metafacades.uml.StateVertexFacade
870     */
871    public boolean isStateVertexFacadeMetaType()
872    {
873        return true;
874    }
875
876    /**
877     * @return true
878     * @see ModelElementFacade
879     */
880    public boolean isModelElementFacadeMetaType()
881    {
882        return true;
883    }
884
885    // ----------- delegates to FrontEndView ------------
886    /**
887     * The entry action for this action state (if any).
888     * @see org.andromda.metafacades.uml.ActionStateFacade#getEntry()
889     */
890    public ActionFacade getEntry()
891    {
892        return this.getSuperFrontEndView().getEntry();
893    }
894
895    /**
896     * The method name representing this action state.
897     * @see org.andromda.metafacades.uml.FrontEndActionState#getActionMethodName()
898     */
899    public String getActionMethodName()
900    {
901        return this.getSuperFrontEndView().getActionMethodName();
902    }
903
904    /**
905     * The actions that pass through this action state.
906     * @see org.andromda.metafacades.uml.FrontEndActionState#getContainerActions()
907     */
908    public List<FrontEndAction> getContainerActions()
909    {
910        return this.getSuperFrontEndView().getContainerActions();
911    }
912
913    /**
914     * All calls deferred to the controller by this action state.
915     * @see org.andromda.metafacades.uml.FrontEndActionState#getControllerCalls()
916     */
917    public List<OperationFacade> getControllerCalls()
918    {
919        return this.getSuperFrontEndView().getControllerCalls();
920    }
921
922    /**
923     * All exceptions modelled on this action state.
924     * @see org.andromda.metafacades.uml.FrontEndActionState#getExceptions()
925     */
926    public List<FrontEndExceptionHandler> getExceptions()
927    {
928        return this.getSuperFrontEndView().getExceptions();
929    }
930
931    /**
932     * The next transition, there can be only one transition going out of an action state, otherwise
933     * decision points should be used (triggers are not supported at the server-side).
934     * @see org.andromda.metafacades.uml.FrontEndActionState#getForward()
935     */
936    public FrontEndForward getForward()
937    {
938        return this.getSuperFrontEndView().getForward();
939    }
940
941    /**
942     * All calls deferred to the services by this action state.
943     * @see org.andromda.metafacades.uml.FrontEndActionState#getServiceCalls()
944     */
945    public List<OperationFacade> getServiceCalls()
946    {
947        return this.getSuperFrontEndView().getServiceCalls();
948    }
949
950    /**
951     * True if this element is contained in a FrontEndUseCase.
952     * @see org.andromda.metafacades.uml.FrontEndActionState#isContainedInFrontEndUseCase()
953     */
954    public boolean isContainedInFrontEndUseCase()
955    {
956        return this.getSuperFrontEndView().isContainedInFrontEndUseCase();
957    }
958
959    /**
960     * Indicates whether or not this front end action state is server side. Pages, for example, are
961     * also action states but they return control to the client.
962     * @see org.andromda.metafacades.uml.FrontEndActionState#isServerSide()
963     */
964    public boolean isServerSide()
965    {
966        return this.getSuperFrontEndView().isServerSide();
967    }
968
969    /**
970     * All actions that can be triggered on this view.
971     * @see FrontEndView#getActions()
972     */
973    public List<FrontEndAction> getActions()
974    {
975        return this.getSuperFrontEndView().getActions();
976    }
977
978    /**
979     * All parameters for each action going out of this view.
980     * @see FrontEndView#getAllActionParameters()
981     */
982    public List<FrontEndParameter> getAllActionParameters()
983    {
984        return this.getSuperFrontEndView().getAllActionParameters();
985    }
986
987    /**
988     * All fields from all forms on the given view.
989     * @see FrontEndView#getAllFormFields()
990     */
991    public List<FrontEndParameter> getAllFormFields()
992    {
993        return this.getSuperFrontEndView().getAllFormFields();
994    }
995
996    /**
997     * All tables belonging to the front end view.
998     * @see FrontEndView#getTables()
999     */
1000    public List<FrontEndParameter> getTables()
1001    {
1002        return this.getSuperFrontEndView().getTables();
1003    }
1004
1005    /**
1006     * The use-case of which this view is a member.
1007     * @see FrontEndView#getUseCase()
1008     */
1009    public FrontEndUseCase getUseCase()
1010    {
1011        return this.getSuperFrontEndView().getUseCase();
1012    }
1013
1014    /**
1015     * All those variables that will be present as variables in the target view. These are the
1016     * trigger parameters on the incoming transitions.
1017     * @see FrontEndView#getVariables()
1018     */
1019    public List<FrontEndParameter> getVariables()
1020    {
1021        return this.getSuperFrontEndView().getVariables();
1022    }
1023
1024    /**
1025     * True if this element carries the FrontEndView stereotype.
1026     * @see FrontEndView#isFrontEndView()
1027     */
1028    public boolean isFrontEndView()
1029    {
1030        return this.getSuperFrontEndView().isFrontEndView();
1031    }
1032
1033    /**
1034     * Copies all tagged values from the given ModelElementFacade to this model element facade.
1035     * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element)
1036     */
1037    public void copyTaggedValues(ModelElementFacade element)
1038    {
1039        this.getSuperFrontEndView().copyTaggedValues(element);
1040    }
1041
1042    /**
1043     * Finds the tagged value with the specified 'tagName'. In case there are more values the first
1044     * one found will be returned.
1045     * @see ModelElementFacade#findTaggedValue(String tagName)
1046     */
1047    public Object findTaggedValue(String tagName)
1048    {
1049        return this.getSuperFrontEndView().findTaggedValue(tagName);
1050    }
1051
1052    /**
1053     * Returns all the values for the tagged value with the specified name. The returned collection
1054     * will contains only String instances, or will be empty. Never null.
1055     * @see ModelElementFacade#findTaggedValues(String tagName)
1056     */
1057    public Collection<Object> findTaggedValues(String tagName)
1058    {
1059        return this.getSuperFrontEndView().findTaggedValues(tagName);
1060    }
1061
1062    /**
1063     * Returns the fully qualified name of the model element. The fully qualified name includes
1064     * complete package qualified name of the underlying model element. The templates parameter will
1065     * be replaced by the correct one given the binding relation of the parameter to this element.
1066     * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement)
1067     */
1068    public String getBindedFullyQualifiedName(ModelElementFacade bindedElement)
1069    {
1070        return this.getSuperFrontEndView().getBindedFullyQualifiedName(bindedElement);
1071    }
1072
1073    /**
1074     * Gets all constraints belonging to the model element.
1075     * @see ModelElementFacade#getConstraints()
1076     */
1077    public Collection<ConstraintFacade> getConstraints()
1078    {
1079        return this.getSuperFrontEndView().getConstraints();
1080    }
1081
1082    /**
1083     * Returns the constraints of the argument kind that have been placed onto this model. Typical
1084     * kinds are "inv", "pre" and "post". Other kinds are possible.
1085     * @see ModelElementFacade#getConstraints(String kind)
1086     */
1087    public Collection<ConstraintFacade> getConstraints(String kind)
1088    {
1089        return this.getSuperFrontEndView().getConstraints(kind);
1090    }
1091
1092    /**
1093     * Gets the documentation for the model element, The indent argument is prefixed to each line.
1094     * By default this method wraps lines after 64 characters.
1095     * This method is equivalent to <code>getDocumentation(indent, 64)</code>.
1096     * @see ModelElementFacade#getDocumentation(String indent)
1097     */
1098    public String getDocumentation(String indent)
1099    {
1100        return this.getSuperFrontEndView().getDocumentation(indent);
1101    }
1102
1103    /**
1104     * This method returns the documentation for this model element, with the lines wrapped after
1105     * the specified number of characters, values of less than 1 will indicate no line wrapping is
1106     * required. By default paragraphs are returned as HTML.
1107     * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>.
1108     * @see ModelElementFacade#getDocumentation(String indent, int lineLength)
1109     */
1110    public String getDocumentation(String indent, int lineLength)
1111    {
1112        return this.getSuperFrontEndView().getDocumentation(indent, lineLength);
1113    }
1114
1115    /**
1116     * This method returns the documentation for this model element, with the lines wrapped after
1117     * the specified number of characters, values of less than 1 will indicate no line wrapping is
1118     * required. HTML style determines if HTML Escaping is applied.
1119     * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle)
1120     */
1121    public String getDocumentation(String indent, int lineLength, boolean htmlStyle)
1122    {
1123        return this.getSuperFrontEndView().getDocumentation(indent, lineLength, htmlStyle);
1124    }
1125
1126    /**
1127     * The fully qualified name of this model element.
1128     * @see ModelElementFacade#getFullyQualifiedName()
1129     */
1130    public String getFullyQualifiedName()
1131    {
1132        return this.getSuperFrontEndView().getFullyQualifiedName();
1133    }
1134
1135    /**
1136     * Returns the fully qualified name of the model element. The fully qualified name includes
1137     * complete package qualified name of the underlying model element.  If modelName is true, then
1138     * the original name of the model element (the name contained within the model) will be the name
1139     * returned, otherwise a name from a language mapping will be returned.
1140     * @see ModelElementFacade#getFullyQualifiedName(boolean modelName)
1141     */
1142    public String getFullyQualifiedName(boolean modelName)
1143    {
1144        return this.getSuperFrontEndView().getFullyQualifiedName(modelName);
1145    }
1146
1147    /**
1148     * Returns the fully qualified name as a path, the returned value always starts with out a slash
1149     * '/'.
1150     * @see ModelElementFacade#getFullyQualifiedNamePath()
1151     */
1152    public String getFullyQualifiedNamePath()
1153    {
1154        return this.getSuperFrontEndView().getFullyQualifiedNamePath();
1155    }
1156
1157    /**
1158     * Gets the unique identifier of the underlying model element.
1159     * @see ModelElementFacade#getId()
1160     */
1161    public String getId()
1162    {
1163        return this.getSuperFrontEndView().getId();
1164    }
1165
1166    /**
1167     * UML2: Retrieves the keywords for this element. Used to modify implementation properties which
1168     * are not represented by other properties, i.e. native, transient, volatile, synchronized,
1169     * (added annotations) override, deprecated. Can also be used to suppress compiler warnings:
1170     * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require
1171     * JDK5 compiler level.
1172     * @see ModelElementFacade#getKeywords()
1173     */
1174    public Collection<String> getKeywords()
1175    {
1176        return this.getSuperFrontEndView().getKeywords();
1177    }
1178
1179    /**
1180     * UML2: Retrieves a localized label for this named element.
1181     * @see ModelElementFacade#getLabel()
1182     */
1183    public String getLabel()
1184    {
1185        return this.getSuperFrontEndView().getLabel();
1186    }
1187
1188    /**
1189     * The language mappings that have been set for this model element.
1190     * @see ModelElementFacade#getLanguageMappings()
1191     */
1192    public TypeMappings getLanguageMappings()
1193    {
1194        return this.getSuperFrontEndView().getLanguageMappings();
1195    }
1196
1197    /**
1198     * Return the model containing this model element (multiple models may be loaded and processed
1199     * at the same time).
1200     * @see ModelElementFacade#getModel()
1201     */
1202    public ModelFacade getModel()
1203    {
1204        return this.getSuperFrontEndView().getModel();
1205    }
1206
1207    /**
1208     * The name of the model element.
1209     * @see ModelElementFacade#getName()
1210     */
1211    public String getName()
1212    {
1213        return this.getSuperFrontEndView().getName();
1214    }
1215
1216    /**
1217     * Gets the package to which this model element belongs.
1218     * @see ModelElementFacade#getPackage()
1219     */
1220    public ModelElementFacade getPackage()
1221    {
1222        return this.getSuperFrontEndView().getPackage();
1223    }
1224
1225    /**
1226     * The name of this model element's package.
1227     * @see ModelElementFacade#getPackageName()
1228     */
1229    public String getPackageName()
1230    {
1231        return this.getSuperFrontEndView().getPackageName();
1232    }
1233
1234    /**
1235     * Gets the package name (optionally providing the ability to retrieve the model name and not
1236     * the mapped name).
1237     * @see ModelElementFacade#getPackageName(boolean modelName)
1238     */
1239    public String getPackageName(boolean modelName)
1240    {
1241        return this.getSuperFrontEndView().getPackageName(modelName);
1242    }
1243
1244    /**
1245     * Returns the package as a path, the returned value always starts with out a slash '/'.
1246     * @see ModelElementFacade#getPackagePath()
1247     */
1248    public String getPackagePath()
1249    {
1250        return this.getSuperFrontEndView().getPackagePath();
1251    }
1252
1253    /**
1254     * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the
1255     * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from
1256     * the names of the containing namespaces starting at the root of the hierarchy and ending with
1257     * the name of the NamedElement itself.
1258     * @see ModelElementFacade#getQualifiedName()
1259     */
1260    public String getQualifiedName()
1261    {
1262        return this.getSuperFrontEndView().getQualifiedName();
1263    }
1264
1265    /**
1266     * Gets the root package for the model element.
1267     * @see ModelElementFacade#getRootPackage()
1268     */
1269    public PackageFacade getRootPackage()
1270    {
1271        return this.getSuperFrontEndView().getRootPackage();
1272    }
1273
1274    /**
1275     * Gets the dependencies for which this model element is the source.
1276     * @see ModelElementFacade#getSourceDependencies()
1277     */
1278    public Collection<DependencyFacade> getSourceDependencies()
1279    {
1280        return this.getSuperFrontEndView().getSourceDependencies();
1281    }
1282
1283    /**
1284     * If this model element is the context of an activity graph, this represents that activity
1285     * graph.
1286     * @see ModelElementFacade#getStateMachineContext()
1287     */
1288    public StateMachineFacade getStateMachineContext()
1289    {
1290        return this.getSuperFrontEndView().getStateMachineContext();
1291    }
1292
1293    /**
1294     * The collection of ALL stereotype names for this model element.
1295     * @see ModelElementFacade#getStereotypeNames()
1296     */
1297    public Collection<String> getStereotypeNames()
1298    {
1299        return this.getSuperFrontEndView().getStereotypeNames();
1300    }
1301
1302    /**
1303     * Gets all stereotypes for this model element.
1304     * @see ModelElementFacade#getStereotypes()
1305     */
1306    public Collection<StereotypeFacade> getStereotypes()
1307    {
1308        return this.getSuperFrontEndView().getStereotypes();
1309    }
1310
1311    /**
1312     * Return the TaggedValues associated with this model element, under all stereotypes.
1313     * @see ModelElementFacade#getTaggedValues()
1314     */
1315    public Collection<TaggedValueFacade> getTaggedValues()
1316    {
1317        return this.getSuperFrontEndView().getTaggedValues();
1318    }
1319
1320    /**
1321     * Gets the dependencies for which this model element is the target.
1322     * @see ModelElementFacade#getTargetDependencies()
1323     */
1324    public Collection<DependencyFacade> getTargetDependencies()
1325    {
1326        return this.getSuperFrontEndView().getTargetDependencies();
1327    }
1328
1329    /**
1330     * Get the template parameter for this model element having the parameterName
1331     * @see ModelElementFacade#getTemplateParameter(String parameterName)
1332     */
1333    public Object getTemplateParameter(String parameterName)
1334    {
1335        return this.getSuperFrontEndView().getTemplateParameter(parameterName);
1336    }
1337
1338    /**
1339     * Get the template parameters for this model element
1340     * @see ModelElementFacade#getTemplateParameters()
1341     */
1342    public Collection<TemplateParameterFacade> getTemplateParameters()
1343    {
1344        return this.getSuperFrontEndView().getTemplateParameters();
1345    }
1346
1347    /**
1348     * The visibility (i.e. public, private, protected or package) of the model element, will
1349     * attempt a lookup for these values in the language mappings (if any).
1350     * @see ModelElementFacade#getVisibility()
1351     */
1352    public String getVisibility()
1353    {
1354        return this.getSuperFrontEndView().getVisibility();
1355    }
1356
1357    /**
1358     * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance
1359     * is taken into account when searching for the stereotype), false otherwise.
1360     * @see ModelElementFacade#hasExactStereotype(String stereotypeName)
1361     */
1362    public boolean hasExactStereotype(String stereotypeName)
1363    {
1364        return this.getSuperFrontEndView().hasExactStereotype(stereotypeName);
1365    }
1366
1367    /**
1368     * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma,
1369     * pipe, semicolon, or << >>
1370     * @see ModelElementFacade#hasKeyword(String keywordName)
1371     */
1372    public boolean hasKeyword(String keywordName)
1373    {
1374        return this.getSuperFrontEndView().hasKeyword(keywordName);
1375    }
1376
1377    /**
1378     * Returns true if the model element has the specified stereotype.  If the stereotype itself
1379     * does not match, then a search will be made up the stereotype inheritance hierarchy, and if
1380     * one of the stereotype's ancestors has a matching name this method will return true, false
1381     * otherwise.
1382     * For example, if we have a certain stereotype called <<exception>> and a model element has a
1383     * stereotype called <<applicationException>> which extends <<exception>>, when calling this
1384     * method with 'stereotypeName' defined as 'exception' the method would return true since
1385     * <<applicationException>> inherits from <<exception>>.  If you want to check if the model
1386     * element has the exact stereotype, then use the method 'hasExactStereotype' instead.
1387     * @see ModelElementFacade#hasStereotype(String stereotypeName)
1388     */
1389    public boolean hasStereotype(String stereotypeName)
1390    {
1391        return this.getSuperFrontEndView().hasStereotype(stereotypeName);
1392    }
1393
1394    /**
1395     * True if there are target dependencies from this element that are instances of BindingFacade.
1396     * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies.
1397     * @see ModelElementFacade#isBindingDependenciesPresent()
1398     */
1399    public boolean isBindingDependenciesPresent()
1400    {
1401        return this.getSuperFrontEndView().isBindingDependenciesPresent();
1402    }
1403
1404    /**
1405     * Indicates if any constraints are present on this model element.
1406     * @see ModelElementFacade#isConstraintsPresent()
1407     */
1408    public boolean isConstraintsPresent()
1409    {
1410        return this.getSuperFrontEndView().isConstraintsPresent();
1411    }
1412
1413    /**
1414     * Indicates if any documentation is present on this model element.
1415     * @see ModelElementFacade#isDocumentationPresent()
1416     */
1417    public boolean isDocumentationPresent()
1418    {
1419        return this.getSuperFrontEndView().isDocumentationPresent();
1420    }
1421
1422    /**
1423     * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript.
1424     * @see ModelElementFacade#isReservedWord()
1425     */
1426    public boolean isReservedWord()
1427    {
1428        return this.getSuperFrontEndView().isReservedWord();
1429    }
1430
1431    /**
1432     * True is there are template parameters on this model element. For UML2, applies to Class,
1433     * Operation, Property, and Parameter.
1434     * @see ModelElementFacade#isTemplateParametersPresent()
1435     */
1436    public boolean isTemplateParametersPresent()
1437    {
1438        return this.getSuperFrontEndView().isTemplateParametersPresent();
1439    }
1440
1441    /**
1442     * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++,
1443     * JavaScript. Contains no spaces, special characters etc. Constraint always applied on
1444     * Enumerations and Interfaces, optionally applies on other model elements.
1445     * @see ModelElementFacade#isValidIdentifierName()
1446     */
1447    public boolean isValidIdentifierName()
1448    {
1449        return this.getSuperFrontEndView().isValidIdentifierName();
1450    }
1451
1452    /**
1453     * Searches for the constraint with the specified 'name' on this model element, and if found
1454     * translates it using the specified 'translation' from a translation library discovered by the
1455     * framework.
1456     * @see ModelElementFacade#translateConstraint(String name, String translation)
1457     */
1458    public String translateConstraint(String name, String translation)
1459    {
1460        return this.getSuperFrontEndView().translateConstraint(name, translation);
1461    }
1462
1463    /**
1464     * Translates all constraints belonging to this model element with the given 'translation'.
1465     * @see ModelElementFacade#translateConstraints(String translation)
1466     */
1467    public String[] translateConstraints(String translation)
1468    {
1469        return this.getSuperFrontEndView().translateConstraints(translation);
1470    }
1471
1472    /**
1473     * Translates the constraints of the specified 'kind' belonging to this model element.
1474     * @see ModelElementFacade#translateConstraints(String kind, String translation)
1475     */
1476    public String[] translateConstraints(String kind, String translation)
1477    {
1478        return this.getSuperFrontEndView().translateConstraints(kind, translation);
1479    }
1480
1481    /**
1482     * Events to which is being deferred in this action state.
1483     * @see StateFacade#getDeferrableEvents()
1484     */
1485    public Collection<EventFacade> getDeferrableEvents()
1486    {
1487        return this.getSuperFrontEndView().getDeferrableEvents();
1488    }
1489
1490    /**
1491     * Models a situation during which some (usually implicit) invariant condition holds. The states
1492     * of
1493     * protocol state machines are exposed to the users of their context classifiers. A protocol
1494     * state
1495     * represents an exposed stable situation of its context classifier: when an instance of the
1496     * classifier
1497     * is not processing any operation, users of this instance can always know its state
1498     * configuration.
1499     * @see org.andromda.metafacades.uml.StateVertexFacade#getContainer()
1500     */
1501    public StateFacade getContainer()
1502    {
1503        return this.getSuperFrontEndView().getContainer();
1504    }
1505
1506    /**
1507     * A directed relationship between a source vertex and a target vertex. It may be part of a
1508     * compound
1509     * transition, which takes the state machine from one state configuration to another,
1510     * representing the
1511     * complete response of the state machine to an occurrence of an event of a particular type.
1512     * @see org.andromda.metafacades.uml.StateVertexFacade#getIncomings()
1513     */
1514    public Collection<TransitionFacade> getIncomings()
1515    {
1516        return this.getSuperFrontEndView().getIncomings();
1517    }
1518
1519    /**
1520     * A directed relationship between a source vertex and a target vertex. It may be part of a
1521     * compound
1522     * transition, which takes the state machine from one state configuration to another,
1523     * representing the
1524     * complete response of the state machine to an occurrence of an event of a particular type.
1525     * @see org.andromda.metafacades.uml.StateVertexFacade#getOutgoings()
1526     */
1527    public Collection<TransitionFacade> getOutgoings()
1528    {
1529        return this.getSuperFrontEndView().getOutgoings();
1530    }
1531
1532    /**
1533     * The partition (if any) to which this vertex belongs.
1534     * @see org.andromda.metafacades.uml.StateVertexFacade#getPartition()
1535     */
1536    public PartitionFacade getPartition()
1537    {
1538        return this.getSuperFrontEndView().getPartition();
1539    }
1540
1541    /**
1542     * State machines can be used to express the behavior of part of a system. Behavior is modeled
1543     * as a
1544     * traversal of a graph of state nodes interconnected by one or more joined transition arcs that
1545     * are
1546     * triggered by the dispatching of series of (event) occurrences. During this traversal, the
1547     * state
1548     * machine executes a series of activities associated with various elements of the state
1549     * machine.
1550     * @see org.andromda.metafacades.uml.StateVertexFacade#getStateMachine()
1551     */
1552    public StateMachineFacade getStateMachine()
1553    {
1554        return this.getSuperFrontEndView().getStateMachine();
1555    }
1556
1557    /**
1558     * @see MetafacadeBase#initialize()
1559     */
1560    @Override
1561    public void initialize()
1562    {
1563        this.getSuperFrontEndView().initialize();
1564    }
1565
1566    /**
1567     * @return Object getSuperFrontEndView().getValidationOwner()
1568     * @see MetafacadeBase#getValidationOwner()
1569     */
1570    @Override
1571    public Object getValidationOwner()
1572    {
1573        Object owner = this.getSuperFrontEndView().getValidationOwner();
1574        return owner;
1575    }
1576
1577    /**
1578     * @return String getSuperFrontEndView().getValidationName()
1579     * @see MetafacadeBase#getValidationName()
1580     */
1581    @Override
1582    public String getValidationName()
1583    {
1584        String name = this.getSuperFrontEndView().getValidationName();
1585        return name;
1586    }
1587
1588    /**
1589     * <p><b>Constraint:</b> org::andromda::cartridges::jsf::metafacades::JSFView::duplicate view action names not allowed</p>
1590     * <p><b>Error:</b> Each view must contain actions which each have a unique name, this view has actions with duplicate names or names that cause an action name to be duplicated in faces-config.xml.</p>
1591     * <p><b>OCL:</b> context JSFView inv: actions->isUnique(name)</p>
1592     * @param validationMessages Collection<ModelValidationMessage>
1593     * @see MetafacadeBase#validateInvariants(Collection validationMessages)
1594     */
1595    @Override
1596    public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
1597    {
1598        this.getSuperFrontEndView().validateInvariants(validationMessages);
1599        try
1600        {
1601            final Object contextElement = this.THIS();
1602            boolean constraintValid = OCLResultEnsurer.ensure(OCLCollections.isUnique(OCLIntrospector.invoke(contextElement,"actions"),new Transformer(){public Object transform(Object object){return OCLIntrospector.invoke(object,"name");}}));
1603            if (!constraintValid)
1604            {
1605                validationMessages.add(
1606                    new ModelValidationMessage(
1607                        (MetafacadeBase)contextElement ,
1608                        "org::andromda::cartridges::jsf::metafacades::JSFView::duplicate view action names not allowed",
1609                        "Each view must contain actions which each have a unique name, this view has actions with duplicate names or names that cause an action name to be duplicated in faces-config.xml."));
1610            }
1611        }
1612        catch (Throwable th)
1613        {
1614            Throwable cause = th.getCause();
1615            int depth = 0; // Some throwables have infinite recursion
1616            while (cause != null && depth < 7)
1617            {
1618                th = cause;
1619                depth++;
1620            }
1621            logger.error("Error validating constraint 'org::andromda::cartridges::jsf::metafacades::JSFView::duplicate view action names not allowed' ON "
1622                + this.THIS().toString() + ": " + th.getMessage(), th);
1623        }
1624    }
1625
1626    /**
1627     * The property that stores the name of the metafacade.
1628     */
1629    private static final String NAME_PROPERTY = "name";
1630    private static final String FQNAME_PROPERTY = "fullyQualifiedName";
1631
1632    /**
1633     * @see Object#toString()
1634     */
1635    @Override
1636    public String toString()
1637    {
1638        final StringBuilder toString = new StringBuilder(this.getClass().getName());
1639        toString.append("[");
1640        try
1641        {
1642            toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY));
1643        }
1644        catch (final Throwable tryAgain)
1645        {
1646            try
1647            {
1648                toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY));
1649            }
1650            catch (final Throwable ignore)
1651            {
1652                // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property
1653            }
1654        }
1655        toString.append("]");
1656        return toString.toString();
1657    }
1658}