View Javadoc
1   // license-header java merge-point
2   //
3   // Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
4   //
5   package org.andromda.cartridges.bpm4struts.metafacades;
6   
7   import java.util.Collection;
8   import java.util.List;
9   import org.andromda.core.common.Introspector;
10  import org.andromda.core.metafacade.MetafacadeBase;
11  import org.andromda.core.metafacade.MetafacadeFactory;
12  import org.andromda.core.metafacade.ModelValidationMessage;
13  import org.andromda.metafacades.uml.ActionFacade;
14  import org.andromda.metafacades.uml.ConstraintFacade;
15  import org.andromda.metafacades.uml.DependencyFacade;
16  import org.andromda.metafacades.uml.EventFacade;
17  import org.andromda.metafacades.uml.FrontEndAction;
18  import org.andromda.metafacades.uml.FrontEndExceptionHandler;
19  import org.andromda.metafacades.uml.FrontEndForward;
20  import org.andromda.metafacades.uml.FrontEndParameter;
21  import org.andromda.metafacades.uml.FrontEndUseCase;
22  import org.andromda.metafacades.uml.FrontEndView;
23  import org.andromda.metafacades.uml.ModelElementFacade;
24  import org.andromda.metafacades.uml.ModelFacade;
25  import org.andromda.metafacades.uml.OperationFacade;
26  import org.andromda.metafacades.uml.PackageFacade;
27  import org.andromda.metafacades.uml.PartitionFacade;
28  import org.andromda.metafacades.uml.StateFacade;
29  import org.andromda.metafacades.uml.StateMachineFacade;
30  import org.andromda.metafacades.uml.StereotypeFacade;
31  import org.andromda.metafacades.uml.TaggedValueFacade;
32  import org.andromda.metafacades.uml.TemplateParameterFacade;
33  import org.andromda.metafacades.uml.TransitionFacade;
34  import org.andromda.metafacades.uml.TypeMappings;
35  import org.apache.log4j.Logger;
36  
37  /**
38   * A Struts JSP represents a page in the web application. A page possibly contains several forms and
39   * triggers (either buttons or hyperlinks) that call actions.
40   * MetafacadeLogic for StrutsJsp
41   *
42   * @see StrutsJsp
43   */
44  public abstract class StrutsJspLogic
45      extends MetafacadeBase
46      implements StrutsJsp
47  {
48      /**
49       * The underlying UML object
50       * @see Object
51       */
52      protected Object metaObject;
53  
54      /** Create Metafacade implementation instance using the MetafacadeFactory from the context
55       * @param metaObjectIn
56       * @param context
57       */
58      protected StrutsJspLogic(Object metaObjectIn, String context)
59      {
60          super(metaObjectIn, getContext(context));
61          this.superStrutsActionState =
62             (StrutsActionState)
63              MetafacadeFactory.getInstance().createFacadeImpl(
64                      "org.andromda.cartridges.bpm4struts.metafacades.StrutsActionState",
65                      metaObjectIn,
66                      getContext(context));
67          this.superFrontEndView =
68             (FrontEndView)
69              MetafacadeFactory.getInstance().createFacadeImpl(
70                      "org.andromda.metafacades.uml.FrontEndView",
71                      metaObjectIn,
72                      getContext(context));
73          this.metaObject = metaObjectIn;
74      }
75  
76      /**
77       * The logger instance.
78       */
79      private static final Logger logger = Logger.getLogger(StrutsJspLogic.class);
80  
81      /**
82       * Gets the context for this metafacade logic instance.
83       * @param context String. Set to StrutsJsp if null
84       * @return context String
85       */
86      private static String getContext(String context)
87      {
88          if (context == null)
89          {
90              context = "org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp";
91          }
92          return context;
93      }
94  
95      private StrutsActionState superStrutsActionState;
96      private boolean superStrutsActionStateInitialized = false;
97  
98      /**
99       * Gets the StrutsActionState parent instance.
100      * @return this.superStrutsActionState StrutsActionState
101      */
102     protected StrutsActionState getSuperStrutsActionState()
103     {
104         if (!this.superStrutsActionStateInitialized)
105         {
106             ((MetafacadeBase)this.superStrutsActionState).setMetafacadeContext(this.getMetafacadeContext());
107             this.superStrutsActionStateInitialized = true;
108         }
109         return this.superStrutsActionState;
110     }
111 
112     private FrontEndView superFrontEndView;
113     private boolean superFrontEndViewInitialized = false;
114 
115     /**
116      * Gets the FrontEndView parent instance.
117      * @return this.superFrontEndView FrontEndView
118      */
119     protected FrontEndView getSuperFrontEndView()
120     {
121         if (!this.superFrontEndViewInitialized)
122         {
123             ((MetafacadeBase)this.superFrontEndView).setMetafacadeContext(this.getMetafacadeContext());
124             this.superFrontEndViewInitialized = true;
125         }
126         return this.superFrontEndView;
127     }
128 
129     /** Reset context only for non-root metafacades
130      * @param context
131      * @see org.andromda.core.metafacade.MetafacadeBase#resetMetafacadeContext(String context)
132      */
133     @Override
134     public void resetMetafacadeContext(String context)
135     {
136         if (!this.contextRoot) // reset context only for non-root metafacades
137         {
138             context = getContext(context);  // to have same value as in original constructor call
139             setMetafacadeContext (context);
140             if (this.superStrutsActionStateInitialized)
141             {
142                 ((MetafacadeBase)this.superStrutsActionState).resetMetafacadeContext(context);
143             }
144             if (this.superFrontEndViewInitialized)
145             {
146                 ((MetafacadeBase)this.superFrontEndView).resetMetafacadeContext(context);
147             }
148         }
149     }
150 
151     /**
152      * @return boolean true always
153      * @see StrutsJsp
154      */
155     public boolean isStrutsJspMetaType()
156     {
157         return true;
158     }
159 
160     // --------------- attributes ---------------------
161 
162    /**
163     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp#getFullPath()
164     * @return String
165     */
166     protected abstract String handleGetFullPath();
167 
168     private String __fullPath1a;
169     private boolean __fullPath1aSet = false;
170 
171     /**
172      * The full path to this JSP page. the returned String does not have a suffix such as '.jsp'.
173      * @return (String)handleGetFullPath()
174      */
175     public final String getFullPath()
176     {
177         String fullPath1a = this.__fullPath1a;
178         if (!this.__fullPath1aSet)
179         {
180             // fullPath has no pre constraints
181             fullPath1a = handleGetFullPath();
182             // fullPath has no post constraints
183             this.__fullPath1a = fullPath1a;
184             if (isMetafacadePropertyCachingEnabled())
185             {
186                 this.__fullPath1aSet = true;
187             }
188         }
189         return fullPath1a;
190     }
191 
192    /**
193     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp#getTitleKey()
194     * @return String
195     */
196     protected abstract String handleGetTitleKey();
197 
198     private String __titleKey2a;
199     private boolean __titleKey2aSet = false;
200 
201     /**
202      * A resource message key suited for the page's title.
203      * @return (String)handleGetTitleKey()
204      */
205     public final String getTitleKey()
206     {
207         String titleKey2a = this.__titleKey2a;
208         if (!this.__titleKey2aSet)
209         {
210             // titleKey has no pre constraints
211             titleKey2a = handleGetTitleKey();
212             // titleKey has no post constraints
213             this.__titleKey2a = titleKey2a;
214             if (isMetafacadePropertyCachingEnabled())
215             {
216                 this.__titleKey2aSet = true;
217             }
218         }
219         return titleKey2a;
220     }
221 
222    /**
223     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp#getTitleValue()
224     * @return String
225     */
226     protected abstract String handleGetTitleValue();
227 
228     private String __titleValue3a;
229     private boolean __titleValue3aSet = false;
230 
231     /**
232      * A default resource message value suited for the page's title.
233      * @return (String)handleGetTitleValue()
234      */
235     public final String getTitleValue()
236     {
237         String titleValue3a = this.__titleValue3a;
238         if (!this.__titleValue3aSet)
239         {
240             // titleValue has no pre constraints
241             titleValue3a = handleGetTitleValue();
242             // titleValue has no post constraints
243             this.__titleValue3a = titleValue3a;
244             if (isMetafacadePropertyCachingEnabled())
245             {
246                 this.__titleValue3aSet = true;
247             }
248         }
249         return titleValue3a;
250     }
251 
252    /**
253     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp#getMessageKey()
254     * @return String
255     */
256     protected abstract String handleGetMessageKey();
257 
258     private String __messageKey4a;
259     private boolean __messageKey4aSet = false;
260 
261     /**
262      * The default resource message key.
263      * @return (String)handleGetMessageKey()
264      */
265     public final String getMessageKey()
266     {
267         String messageKey4a = this.__messageKey4a;
268         if (!this.__messageKey4aSet)
269         {
270             // messageKey has no pre constraints
271             messageKey4a = handleGetMessageKey();
272             // messageKey has no post constraints
273             this.__messageKey4a = messageKey4a;
274             if (isMetafacadePropertyCachingEnabled())
275             {
276                 this.__messageKey4aSet = true;
277             }
278         }
279         return messageKey4a;
280     }
281 
282    /**
283     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp#getDocumentationKey()
284     * @return String
285     */
286     protected abstract String handleGetDocumentationKey();
287 
288     private String __documentationKey5a;
289     private boolean __documentationKey5aSet = false;
290 
291     /**
292      * A resource message key suited for the page's documentation.
293      * @return (String)handleGetDocumentationKey()
294      */
295     public final String getDocumentationKey()
296     {
297         String documentationKey5a = this.__documentationKey5a;
298         if (!this.__documentationKey5aSet)
299         {
300             // documentationKey has no pre constraints
301             documentationKey5a = handleGetDocumentationKey();
302             // documentationKey has no post constraints
303             this.__documentationKey5a = documentationKey5a;
304             if (isMetafacadePropertyCachingEnabled())
305             {
306                 this.__documentationKey5aSet = true;
307             }
308         }
309         return documentationKey5a;
310     }
311 
312    /**
313     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp#getDocumentationValue()
314     * @return String
315     */
316     protected abstract String handleGetDocumentationValue();
317 
318     private String __documentationValue6a;
319     private boolean __documentationValue6aSet = false;
320 
321     /**
322      * A resource message value suited for the page's documentation.
323      * @return (String)handleGetDocumentationValue()
324      */
325     public final String getDocumentationValue()
326     {
327         String documentationValue6a = this.__documentationValue6a;
328         if (!this.__documentationValue6aSet)
329         {
330             // documentationValue has no pre constraints
331             documentationValue6a = handleGetDocumentationValue();
332             // documentationValue has no post constraints
333             this.__documentationValue6a = documentationValue6a;
334             if (isMetafacadePropertyCachingEnabled())
335             {
336                 this.__documentationValue6aSet = true;
337             }
338         }
339         return documentationValue6a;
340     }
341 
342    /**
343     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp#isValidationRequired()
344     * @return boolean
345     */
346     protected abstract boolean handleIsValidationRequired();
347 
348     private boolean __validationRequired7a;
349     private boolean __validationRequired7aSet = false;
350 
351     /**
352      * True if at least one client/server parameter requires validation.
353      * @return (boolean)handleIsValidationRequired()
354      */
355     public final boolean isValidationRequired()
356     {
357         boolean validationRequired7a = this.__validationRequired7a;
358         if (!this.__validationRequired7aSet)
359         {
360             // validationRequired has no pre constraints
361             validationRequired7a = handleIsValidationRequired();
362             // validationRequired has no post constraints
363             this.__validationRequired7a = validationRequired7a;
364             if (isMetafacadePropertyCachingEnabled())
365             {
366                 this.__validationRequired7aSet = true;
367             }
368         }
369         return validationRequired7a;
370     }
371 
372    /**
373     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp#isDateFieldPresent()
374     * @return boolean
375     */
376     protected abstract boolean handleIsDateFieldPresent();
377 
378     private boolean __dateFieldPresent8a;
379     private boolean __dateFieldPresent8aSet = false;
380 
381     /**
382      * True if any of the actions have a parameter of type Date.
383      * @return (boolean)handleIsDateFieldPresent()
384      */
385     public final boolean isDateFieldPresent()
386     {
387         boolean dateFieldPresent8a = this.__dateFieldPresent8a;
388         if (!this.__dateFieldPresent8aSet)
389         {
390             // dateFieldPresent has no pre constraints
391             dateFieldPresent8a = handleIsDateFieldPresent();
392             // dateFieldPresent has no post constraints
393             this.__dateFieldPresent8a = dateFieldPresent8a;
394             if (isMetafacadePropertyCachingEnabled())
395             {
396                 this.__dateFieldPresent8aSet = true;
397             }
398         }
399         return dateFieldPresent8a;
400     }
401 
402    /**
403     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp#isCalendarRequired()
404     * @return boolean
405     */
406     protected abstract boolean handleIsCalendarRequired();
407 
408     private boolean __calendarRequired9a;
409     private boolean __calendarRequired9aSet = false;
410 
411     /**
412      * True if this JSP contains a date field which requires a calendar popup.
413      * @return (boolean)handleIsCalendarRequired()
414      */
415     public final boolean isCalendarRequired()
416     {
417         boolean calendarRequired9a = this.__calendarRequired9a;
418         if (!this.__calendarRequired9aSet)
419         {
420             // calendarRequired has no pre constraints
421             calendarRequired9a = handleIsCalendarRequired();
422             // calendarRequired has no post constraints
423             this.__calendarRequired9a = calendarRequired9a;
424             if (isMetafacadePropertyCachingEnabled())
425             {
426                 this.__calendarRequired9aSet = true;
427             }
428         }
429         return calendarRequired9a;
430     }
431 
432    /**
433     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp#getOnlineHelpKey()
434     * @return String
435     */
436     protected abstract String handleGetOnlineHelpKey();
437 
438     private String __onlineHelpKey10a;
439     private boolean __onlineHelpKey10aSet = false;
440 
441     /**
442      * The key to lookup the online help documentation. This documentation is gathered from the
443      * documentation entered by the user, as well as analyzing the model.
444      * @return (String)handleGetOnlineHelpKey()
445      */
446     public final String getOnlineHelpKey()
447     {
448         String onlineHelpKey10a = this.__onlineHelpKey10a;
449         if (!this.__onlineHelpKey10aSet)
450         {
451             // onlineHelpKey has no pre constraints
452             onlineHelpKey10a = handleGetOnlineHelpKey();
453             // onlineHelpKey has no post constraints
454             this.__onlineHelpKey10a = onlineHelpKey10a;
455             if (isMetafacadePropertyCachingEnabled())
456             {
457                 this.__onlineHelpKey10aSet = true;
458             }
459         }
460         return onlineHelpKey10a;
461     }
462 
463    /**
464     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp#getOnlineHelpValue()
465     * @return String
466     */
467     protected abstract String handleGetOnlineHelpValue();
468 
469     private String __onlineHelpValue11a;
470     private boolean __onlineHelpValue11aSet = false;
471 
472     /**
473      * The online help documentation. This documentation is gathered from the documentation entered
474      * by the user, as well as analyzing the model. The format is HTML without any style.
475      * @return (String)handleGetOnlineHelpValue()
476      */
477     public final String getOnlineHelpValue()
478     {
479         String onlineHelpValue11a = this.__onlineHelpValue11a;
480         if (!this.__onlineHelpValue11aSet)
481         {
482             // onlineHelpValue has no pre constraints
483             onlineHelpValue11a = handleGetOnlineHelpValue();
484             // onlineHelpValue has no post constraints
485             this.__onlineHelpValue11a = onlineHelpValue11a;
486             if (isMetafacadePropertyCachingEnabled())
487             {
488                 this.__onlineHelpValue11aSet = true;
489             }
490         }
491         return onlineHelpValue11a;
492     }
493 
494    /**
495     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp#getMessageValue()
496     * @return String
497     */
498     protected abstract String handleGetMessageValue();
499 
500     private String __messageValue12a;
501     private boolean __messageValue12aSet = false;
502 
503     /**
504      * A displayable version of this page's name.
505      * @return (String)handleGetMessageValue()
506      */
507     public final String getMessageValue()
508     {
509         String messageValue12a = this.__messageValue12a;
510         if (!this.__messageValue12aSet)
511         {
512             // messageValue has no pre constraints
513             messageValue12a = handleGetMessageValue();
514             // messageValue has no post constraints
515             this.__messageValue12a = messageValue12a;
516             if (isMetafacadePropertyCachingEnabled())
517             {
518                 this.__messageValue12aSet = true;
519             }
520         }
521         return messageValue12a;
522     }
523 
524    /**
525     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp#getCssFileName()
526     * @return String
527     */
528     protected abstract String handleGetCssFileName();
529 
530     private String __cssFileName13a;
531     private boolean __cssFileName13aSet = false;
532 
533     /**
534      * The name of the file containing specific styles for this page only.
535      * @return (String)handleGetCssFileName()
536      */
537     public final String getCssFileName()
538     {
539         String cssFileName13a = this.__cssFileName13a;
540         if (!this.__cssFileName13aSet)
541         {
542             // cssFileName has no pre constraints
543             cssFileName13a = handleGetCssFileName();
544             // cssFileName has no post constraints
545             this.__cssFileName13a = cssFileName13a;
546             if (isMetafacadePropertyCachingEnabled())
547             {
548                 this.__cssFileName13aSet = true;
549             }
550         }
551         return cssFileName13a;
552     }
553 
554    /**
555     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp#getOnlineHelpActionPath()
556     * @return String
557     */
558     protected abstract String handleGetOnlineHelpActionPath();
559 
560     private String __onlineHelpActionPath14a;
561     private boolean __onlineHelpActionPath14aSet = false;
562 
563     /**
564      * The full path to this JSP's online help action. The returned String does not have a suffix
565      * such as '.do'.
566      * @return (String)handleGetOnlineHelpActionPath()
567      */
568     public final String getOnlineHelpActionPath()
569     {
570         String onlineHelpActionPath14a = this.__onlineHelpActionPath14a;
571         if (!this.__onlineHelpActionPath14aSet)
572         {
573             // onlineHelpActionPath has no pre constraints
574             onlineHelpActionPath14a = handleGetOnlineHelpActionPath();
575             // onlineHelpActionPath has no post constraints
576             this.__onlineHelpActionPath14a = onlineHelpActionPath14a;
577             if (isMetafacadePropertyCachingEnabled())
578             {
579                 this.__onlineHelpActionPath14aSet = true;
580             }
581         }
582         return onlineHelpActionPath14a;
583     }
584 
585    /**
586     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsJsp#getOnlineHelpPagePath()
587     * @return String
588     */
589     protected abstract String handleGetOnlineHelpPagePath();
590 
591     private String __onlineHelpPagePath15a;
592     private boolean __onlineHelpPagePath15aSet = false;
593 
594     /**
595      * The full path to this JSP's online help page. The returned String does not have a suffix such
596      * as '.jsp'.
597      * @return (String)handleGetOnlineHelpPagePath()
598      */
599     public final String getOnlineHelpPagePath()
600     {
601         String onlineHelpPagePath15a = this.__onlineHelpPagePath15a;
602         if (!this.__onlineHelpPagePath15aSet)
603         {
604             // onlineHelpPagePath has no pre constraints
605             onlineHelpPagePath15a = handleGetOnlineHelpPagePath();
606             // onlineHelpPagePath has no post constraints
607             this.__onlineHelpPagePath15a = onlineHelpPagePath15a;
608             if (isMetafacadePropertyCachingEnabled())
609             {
610                 this.__onlineHelpPagePath15aSet = true;
611             }
612         }
613         return onlineHelpPagePath15a;
614     }
615 
616     // ------------- associations ------------------
617 
618     private List<StrutsForward> __getNonActionForwards1r;
619     private boolean __getNonActionForwards1rSet = false;
620 
621     /**
622      * A Struts JSP represents a page in the web application. A page possibly contains several forms
623      * and
624      * triggers (either buttons or hyperlinks) that call actions.
625      * @return (List<StrutsForward>)handleGetNonActionForwards()
626      */
627     public final List<StrutsForward> getNonActionForwards()
628     {
629         List<StrutsForward> getNonActionForwards1r = this.__getNonActionForwards1r;
630         if (!this.__getNonActionForwards1rSet)
631         {
632             // strutsJsp has no pre constraints
633             List result = handleGetNonActionForwards();
634             List shieldedResult = this.shieldedElements(result);
635             try
636             {
637                 getNonActionForwards1r = (List<StrutsForward>)shieldedResult;
638             }
639             catch (ClassCastException ex)
640             {
641                 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
642                 StrutsJspLogic.logger.warn("incorrect metafacade cast for StrutsJspLogic.getNonActionForwards List<StrutsForward> " + result + ": " + shieldedResult);
643             }
644             // strutsJsp has no post constraints
645             this.__getNonActionForwards1r = getNonActionForwards1r;
646             if (isMetafacadePropertyCachingEnabled())
647             {
648                 this.__getNonActionForwards1rSet = true;
649             }
650         }
651         return getNonActionForwards1r;
652     }
653 
654     /**
655      * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
656      * @return  List
657      */
658     protected abstract List handleGetNonActionForwards();
659 
660     private List<StrutsAction> __getIncomingActions2r;
661     private boolean __getIncomingActions2rSet = false;
662 
663     /**
664      * The set of pages that are a possible target of the triggering of this action.
665      * @return (List<StrutsAction>)handleGetIncomingActions()
666      */
667     public final List<StrutsAction> getIncomingActions()
668     {
669         List<StrutsAction> getIncomingActions2r = this.__getIncomingActions2r;
670         if (!this.__getIncomingActions2rSet)
671         {
672             // targetPages has no pre constraints
673             List result = handleGetIncomingActions();
674             List shieldedResult = this.shieldedElements(result);
675             try
676             {
677                 getIncomingActions2r = (List<StrutsAction>)shieldedResult;
678             }
679             catch (ClassCastException ex)
680             {
681                 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
682                 StrutsJspLogic.logger.warn("incorrect metafacade cast for StrutsJspLogic.getIncomingActions List<StrutsAction> " + result + ": " + shieldedResult);
683             }
684             // targetPages has no post constraints
685             this.__getIncomingActions2r = getIncomingActions2r;
686             if (isMetafacadePropertyCachingEnabled())
687             {
688                 this.__getIncomingActions2rSet = true;
689             }
690         }
691         return getIncomingActions2r;
692     }
693 
694     /**
695      * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
696      * @return  List
697      */
698     protected abstract List handleGetIncomingActions();
699 
700     private List<StrutsParameter> __getPageVariables3r;
701     private boolean __getPageVariables3rSet = false;
702 
703     /**
704      * A Struts JSP represents a page in the web application. A page possibly contains several forms
705      * and
706      * triggers (either buttons or hyperlinks) that call actions.
707      * @return (List<StrutsParameter>)handleGetPageVariables()
708      */
709     public final List<StrutsParameter> getPageVariables()
710     {
711         List<StrutsParameter> getPageVariables3r = this.__getPageVariables3r;
712         if (!this.__getPageVariables3rSet)
713         {
714             // strutsJsp has no pre constraints
715             List result = handleGetPageVariables();
716             List shieldedResult = this.shieldedElements(result);
717             try
718             {
719                 getPageVariables3r = (List<StrutsParameter>)shieldedResult;
720             }
721             catch (ClassCastException ex)
722             {
723                 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
724                 StrutsJspLogic.logger.warn("incorrect metafacade cast for StrutsJspLogic.getPageVariables List<StrutsParameter> " + result + ": " + shieldedResult);
725             }
726             // strutsJsp has no post constraints
727             this.__getPageVariables3r = getPageVariables3r;
728             if (isMetafacadePropertyCachingEnabled())
729             {
730                 this.__getPageVariables3rSet = true;
731             }
732         }
733         return getPageVariables3r;
734     }
735 
736     /**
737      * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
738      * @return  List
739      */
740     protected abstract List handleGetPageVariables();
741 
742     /**
743      * @return true
744      * @see StrutsActionState
745      */
746     public boolean isStrutsActionStateMetaType()
747     {
748         return true;
749     }
750 
751     /**
752      * @return true
753      * @see FrontEndView
754      */
755     public boolean isFrontEndViewMetaType()
756     {
757         return true;
758     }
759 
760     /**
761      * @return true
762      * @see org.andromda.metafacades.uml.FrontEndActionState
763      */
764     public boolean isFrontEndActionStateMetaType()
765     {
766         return true;
767     }
768 
769     /**
770      * @return true
771      * @see org.andromda.metafacades.uml.ActionStateFacade
772      */
773     public boolean isActionStateFacadeMetaType()
774     {
775         return true;
776     }
777 
778     /**
779      * @return true
780      * @see StateFacade
781      */
782     public boolean isStateFacadeMetaType()
783     {
784         return true;
785     }
786 
787     /**
788      * @return true
789      * @see org.andromda.metafacades.uml.StateVertexFacade
790      */
791     public boolean isStateVertexFacadeMetaType()
792     {
793         return true;
794     }
795 
796     /**
797      * @return true
798      * @see ModelElementFacade
799      */
800     public boolean isModelElementFacadeMetaType()
801     {
802         return true;
803     }
804 
805     // ----------- delegates to StrutsActionState ------------
806     /**
807      * The entry action for this action state (if any).
808      * @see org.andromda.metafacades.uml.ActionStateFacade#getEntry()
809      */
810     public ActionFacade getEntry()
811     {
812         return this.getSuperStrutsActionState().getEntry();
813     }
814 
815     /**
816      * The method name representing this action state.
817      * @see org.andromda.metafacades.uml.FrontEndActionState#getActionMethodName()
818      */
819     public String getActionMethodName()
820     {
821         return this.getSuperStrutsActionState().getActionMethodName();
822     }
823 
824     /**
825      * The actions that pass through this action state.
826      * @see org.andromda.metafacades.uml.FrontEndActionState#getContainerActions()
827      */
828     public List<FrontEndAction> getContainerActions()
829     {
830         return this.getSuperStrutsActionState().getContainerActions();
831     }
832 
833     /**
834      * All calls deferred to the controller by this action state.
835      * @see org.andromda.metafacades.uml.FrontEndActionState#getControllerCalls()
836      */
837     public List<OperationFacade> getControllerCalls()
838     {
839         return this.getSuperStrutsActionState().getControllerCalls();
840     }
841 
842     /**
843      * All exceptions modelled on this action state.
844      * @see org.andromda.metafacades.uml.FrontEndActionState#getExceptions()
845      */
846     public List<FrontEndExceptionHandler> getExceptions()
847     {
848         return this.getSuperStrutsActionState().getExceptions();
849     }
850 
851     /**
852      * The next transition, there can be only one transition going out of an action state, otherwise
853      * decision points should be used (triggers are not supported at the server-side).
854      * @see org.andromda.metafacades.uml.FrontEndActionState#getForward()
855      */
856     public FrontEndForward getForward()
857     {
858         return this.getSuperStrutsActionState().getForward();
859     }
860 
861     /**
862      * All calls deferred to the services by this action state.
863      * @see org.andromda.metafacades.uml.FrontEndActionState#getServiceCalls()
864      */
865     public List<OperationFacade> getServiceCalls()
866     {
867         return this.getSuperStrutsActionState().getServiceCalls();
868     }
869 
870     /**
871      * True if this element is contained in a FrontEndUseCase.
872      * @see org.andromda.metafacades.uml.FrontEndActionState#isContainedInFrontEndUseCase()
873      */
874     public boolean isContainedInFrontEndUseCase()
875     {
876         return this.getSuperStrutsActionState().isContainedInFrontEndUseCase();
877     }
878 
879     /**
880      * Indicates whether or not this front end action state is server side. Pages, for example, are
881      * also action states but they return control to the client.
882      * @see org.andromda.metafacades.uml.FrontEndActionState#isServerSide()
883      */
884     public boolean isServerSide()
885     {
886         return this.getSuperStrutsActionState().isServerSide();
887     }
888 
889     /**
890      * Copies all tagged values from the given ModelElementFacade to this model element facade.
891      * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element)
892      */
893     public void copyTaggedValues(ModelElementFacade element)
894     {
895         this.getSuperStrutsActionState().copyTaggedValues(element);
896     }
897 
898     /**
899      * Finds the tagged value with the specified 'tagName'. In case there are more values the first
900      * one found will be returned.
901      * @see ModelElementFacade#findTaggedValue(String tagName)
902      */
903     public Object findTaggedValue(String tagName)
904     {
905         return this.getSuperStrutsActionState().findTaggedValue(tagName);
906     }
907 
908     /**
909      * Returns all the values for the tagged value with the specified name. The returned collection
910      * will contains only String instances, or will be empty. Never null.
911      * @see ModelElementFacade#findTaggedValues(String tagName)
912      */
913     public Collection<Object> findTaggedValues(String tagName)
914     {
915         return this.getSuperStrutsActionState().findTaggedValues(tagName);
916     }
917 
918     /**
919      * Returns the fully qualified name of the model element. The fully qualified name includes
920      * complete package qualified name of the underlying model element. The templates parameter will
921      * be replaced by the correct one given the binding relation of the parameter to this element.
922      * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement)
923      */
924     public String getBindedFullyQualifiedName(ModelElementFacade bindedElement)
925     {
926         return this.getSuperStrutsActionState().getBindedFullyQualifiedName(bindedElement);
927     }
928 
929     /**
930      * Gets all constraints belonging to the model element.
931      * @see ModelElementFacade#getConstraints()
932      */
933     public Collection<ConstraintFacade> getConstraints()
934     {
935         return this.getSuperStrutsActionState().getConstraints();
936     }
937 
938     /**
939      * Returns the constraints of the argument kind that have been placed onto this model. Typical
940      * kinds are "inv", "pre" and "post". Other kinds are possible.
941      * @see ModelElementFacade#getConstraints(String kind)
942      */
943     public Collection<ConstraintFacade> getConstraints(String kind)
944     {
945         return this.getSuperStrutsActionState().getConstraints(kind);
946     }
947 
948     /**
949      * Gets the documentation for the model element, The indent argument is prefixed to each line.
950      * By default this method wraps lines after 64 characters.
951      * This method is equivalent to <code>getDocumentation(indent, 64)</code>.
952      * @see ModelElementFacade#getDocumentation(String indent)
953      */
954     public String getDocumentation(String indent)
955     {
956         return this.getSuperStrutsActionState().getDocumentation(indent);
957     }
958 
959     /**
960      * This method returns the documentation for this model element, with the lines wrapped after
961      * the specified number of characters, values of less than 1 will indicate no line wrapping is
962      * required. By default paragraphs are returned as HTML.
963      * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>.
964      * @see ModelElementFacade#getDocumentation(String indent, int lineLength)
965      */
966     public String getDocumentation(String indent, int lineLength)
967     {
968         return this.getSuperStrutsActionState().getDocumentation(indent, lineLength);
969     }
970 
971     /**
972      * This method returns the documentation for this model element, with the lines wrapped after
973      * the specified number of characters, values of less than 1 will indicate no line wrapping is
974      * required. HTML style determines if HTML Escaping is applied.
975      * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle)
976      */
977     public String getDocumentation(String indent, int lineLength, boolean htmlStyle)
978     {
979         return this.getSuperStrutsActionState().getDocumentation(indent, lineLength, htmlStyle);
980     }
981 
982     /**
983      * The fully qualified name of this model element.
984      * @see ModelElementFacade#getFullyQualifiedName()
985      */
986     public String getFullyQualifiedName()
987     {
988         return this.getSuperStrutsActionState().getFullyQualifiedName();
989     }
990 
991     /**
992      * Returns the fully qualified name of the model element. The fully qualified name includes
993      * complete package qualified name of the underlying model element.  If modelName is true, then
994      * the original name of the model element (the name contained within the model) will be the name
995      * returned, otherwise a name from a language mapping will be returned.
996      * @see ModelElementFacade#getFullyQualifiedName(boolean modelName)
997      */
998     public String getFullyQualifiedName(boolean modelName)
999     {
1000         return this.getSuperStrutsActionState().getFullyQualifiedName(modelName);
1001     }
1002 
1003     /**
1004      * Returns the fully qualified name as a path, the returned value always starts with out a slash
1005      * '/'.
1006      * @see ModelElementFacade#getFullyQualifiedNamePath()
1007      */
1008     public String getFullyQualifiedNamePath()
1009     {
1010         return this.getSuperStrutsActionState().getFullyQualifiedNamePath();
1011     }
1012 
1013     /**
1014      * Gets the unique identifier of the underlying model element.
1015      * @see ModelElementFacade#getId()
1016      */
1017     public String getId()
1018     {
1019         return this.getSuperStrutsActionState().getId();
1020     }
1021 
1022     /**
1023      * UML2: Retrieves the keywords for this element. Used to modify implementation properties which
1024      * are not represented by other properties, i.e. native, transient, volatile, synchronized,
1025      * (added annotations) override, deprecated. Can also be used to suppress compiler warnings:
1026      * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require
1027      * JDK5 compiler level.
1028      * @see ModelElementFacade#getKeywords()
1029      */
1030     public Collection<String> getKeywords()
1031     {
1032         return this.getSuperStrutsActionState().getKeywords();
1033     }
1034 
1035     /**
1036      * UML2: Retrieves a localized label for this named element.
1037      * @see ModelElementFacade#getLabel()
1038      */
1039     public String getLabel()
1040     {
1041         return this.getSuperStrutsActionState().getLabel();
1042     }
1043 
1044     /**
1045      * The language mappings that have been set for this model element.
1046      * @see ModelElementFacade#getLanguageMappings()
1047      */
1048     public TypeMappings getLanguageMappings()
1049     {
1050         return this.getSuperStrutsActionState().getLanguageMappings();
1051     }
1052 
1053     /**
1054      * Return the model containing this model element (multiple models may be loaded and processed
1055      * at the same time).
1056      * @see ModelElementFacade#getModel()
1057      */
1058     public ModelFacade getModel()
1059     {
1060         return this.getSuperStrutsActionState().getModel();
1061     }
1062 
1063     /**
1064      * The name of the model element.
1065      * @see ModelElementFacade#getName()
1066      */
1067     public String getName()
1068     {
1069         return this.getSuperStrutsActionState().getName();
1070     }
1071 
1072     /**
1073      * Gets the package to which this model element belongs.
1074      * @see ModelElementFacade#getPackage()
1075      */
1076     public ModelElementFacade getPackage()
1077     {
1078         return this.getSuperStrutsActionState().getPackage();
1079     }
1080 
1081     /**
1082      * The name of this model element's package.
1083      * @see ModelElementFacade#getPackageName()
1084      */
1085     public String getPackageName()
1086     {
1087         return this.getSuperStrutsActionState().getPackageName();
1088     }
1089 
1090     /**
1091      * Gets the package name (optionally providing the ability to retrieve the model name and not
1092      * the mapped name).
1093      * @see ModelElementFacade#getPackageName(boolean modelName)
1094      */
1095     public String getPackageName(boolean modelName)
1096     {
1097         return this.getSuperStrutsActionState().getPackageName(modelName);
1098     }
1099 
1100     /**
1101      * Returns the package as a path, the returned value always starts with out a slash '/'.
1102      * @see ModelElementFacade#getPackagePath()
1103      */
1104     public String getPackagePath()
1105     {
1106         return this.getSuperStrutsActionState().getPackagePath();
1107     }
1108 
1109     /**
1110      * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the
1111      * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from
1112      * the names of the containing namespaces starting at the root of the hierarchy and ending with
1113      * the name of the NamedElement itself.
1114      * @see ModelElementFacade#getQualifiedName()
1115      */
1116     public String getQualifiedName()
1117     {
1118         return this.getSuperStrutsActionState().getQualifiedName();
1119     }
1120 
1121     /**
1122      * Gets the root package for the model element.
1123      * @see ModelElementFacade#getRootPackage()
1124      */
1125     public PackageFacade getRootPackage()
1126     {
1127         return this.getSuperStrutsActionState().getRootPackage();
1128     }
1129 
1130     /**
1131      * Gets the dependencies for which this model element is the source.
1132      * @see ModelElementFacade#getSourceDependencies()
1133      */
1134     public Collection<DependencyFacade> getSourceDependencies()
1135     {
1136         return this.getSuperStrutsActionState().getSourceDependencies();
1137     }
1138 
1139     /**
1140      * If this model element is the context of an activity graph, this represents that activity
1141      * graph.
1142      * @see ModelElementFacade#getStateMachineContext()
1143      */
1144     public StateMachineFacade getStateMachineContext()
1145     {
1146         return this.getSuperStrutsActionState().getStateMachineContext();
1147     }
1148 
1149     /**
1150      * The collection of ALL stereotype names for this model element.
1151      * @see ModelElementFacade#getStereotypeNames()
1152      */
1153     public Collection<String> getStereotypeNames()
1154     {
1155         return this.getSuperStrutsActionState().getStereotypeNames();
1156     }
1157 
1158     /**
1159      * Gets all stereotypes for this model element.
1160      * @see ModelElementFacade#getStereotypes()
1161      */
1162     public Collection<StereotypeFacade> getStereotypes()
1163     {
1164         return this.getSuperStrutsActionState().getStereotypes();
1165     }
1166 
1167     /**
1168      * Return the TaggedValues associated with this model element, under all stereotypes.
1169      * @see ModelElementFacade#getTaggedValues()
1170      */
1171     public Collection<TaggedValueFacade> getTaggedValues()
1172     {
1173         return this.getSuperStrutsActionState().getTaggedValues();
1174     }
1175 
1176     /**
1177      * Gets the dependencies for which this model element is the target.
1178      * @see ModelElementFacade#getTargetDependencies()
1179      */
1180     public Collection<DependencyFacade> getTargetDependencies()
1181     {
1182         return this.getSuperStrutsActionState().getTargetDependencies();
1183     }
1184 
1185     /**
1186      * Get the template parameter for this model element having the parameterName
1187      * @see ModelElementFacade#getTemplateParameter(String parameterName)
1188      */
1189     public Object getTemplateParameter(String parameterName)
1190     {
1191         return this.getSuperStrutsActionState().getTemplateParameter(parameterName);
1192     }
1193 
1194     /**
1195      * Get the template parameters for this model element
1196      * @see ModelElementFacade#getTemplateParameters()
1197      */
1198     public Collection<TemplateParameterFacade> getTemplateParameters()
1199     {
1200         return this.getSuperStrutsActionState().getTemplateParameters();
1201     }
1202 
1203     /**
1204      * The visibility (i.e. public, private, protected or package) of the model element, will
1205      * attempt a lookup for these values in the language mappings (if any).
1206      * @see ModelElementFacade#getVisibility()
1207      */
1208     public String getVisibility()
1209     {
1210         return this.getSuperStrutsActionState().getVisibility();
1211     }
1212 
1213     /**
1214      * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance
1215      * is taken into account when searching for the stereotype), false otherwise.
1216      * @see ModelElementFacade#hasExactStereotype(String stereotypeName)
1217      */
1218     public boolean hasExactStereotype(String stereotypeName)
1219     {
1220         return this.getSuperStrutsActionState().hasExactStereotype(stereotypeName);
1221     }
1222 
1223     /**
1224      * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma,
1225      * pipe, semicolon, or << >>
1226      * @see ModelElementFacade#hasKeyword(String keywordName)
1227      */
1228     public boolean hasKeyword(String keywordName)
1229     {
1230         return this.getSuperStrutsActionState().hasKeyword(keywordName);
1231     }
1232 
1233     /**
1234      * Returns true if the model element has the specified stereotype.  If the stereotype itself
1235      * does not match, then a search will be made up the stereotype inheritance hierarchy, and if
1236      * one of the stereotype's ancestors has a matching name this method will return true, false
1237      * otherwise.
1238      * For example, if we have a certain stereotype called <<exception>> and a model element has a
1239      * stereotype called <<applicationException>> which extends <<exception>>, when calling this
1240      * method with 'stereotypeName' defined as 'exception' the method would return true since
1241      * <<applicationException>> inherits from <<exception>>.  If you want to check if the model
1242      * element has the exact stereotype, then use the method 'hasExactStereotype' instead.
1243      * @see ModelElementFacade#hasStereotype(String stereotypeName)
1244      */
1245     public boolean hasStereotype(String stereotypeName)
1246     {
1247         return this.getSuperStrutsActionState().hasStereotype(stereotypeName);
1248     }
1249 
1250     /**
1251      * True if there are target dependencies from this element that are instances of BindingFacade.
1252      * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies.
1253      * @see ModelElementFacade#isBindingDependenciesPresent()
1254      */
1255     public boolean isBindingDependenciesPresent()
1256     {
1257         return this.getSuperStrutsActionState().isBindingDependenciesPresent();
1258     }
1259 
1260     /**
1261      * Indicates if any constraints are present on this model element.
1262      * @see ModelElementFacade#isConstraintsPresent()
1263      */
1264     public boolean isConstraintsPresent()
1265     {
1266         return this.getSuperStrutsActionState().isConstraintsPresent();
1267     }
1268 
1269     /**
1270      * Indicates if any documentation is present on this model element.
1271      * @see ModelElementFacade#isDocumentationPresent()
1272      */
1273     public boolean isDocumentationPresent()
1274     {
1275         return this.getSuperStrutsActionState().isDocumentationPresent();
1276     }
1277 
1278     /**
1279      * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript.
1280      * @see ModelElementFacade#isReservedWord()
1281      */
1282     public boolean isReservedWord()
1283     {
1284         return this.getSuperStrutsActionState().isReservedWord();
1285     }
1286 
1287     /**
1288      * True is there are template parameters on this model element. For UML2, applies to Class,
1289      * Operation, Property, and Parameter.
1290      * @see ModelElementFacade#isTemplateParametersPresent()
1291      */
1292     public boolean isTemplateParametersPresent()
1293     {
1294         return this.getSuperStrutsActionState().isTemplateParametersPresent();
1295     }
1296 
1297     /**
1298      * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++,
1299      * JavaScript. Contains no spaces, special characters etc. Constraint always applied on
1300      * Enumerations and Interfaces, optionally applies on other model elements.
1301      * @see ModelElementFacade#isValidIdentifierName()
1302      */
1303     public boolean isValidIdentifierName()
1304     {
1305         return this.getSuperStrutsActionState().isValidIdentifierName();
1306     }
1307 
1308     /**
1309      * Searches for the constraint with the specified 'name' on this model element, and if found
1310      * translates it using the specified 'translation' from a translation library discovered by the
1311      * framework.
1312      * @see ModelElementFacade#translateConstraint(String name, String translation)
1313      */
1314     public String translateConstraint(String name, String translation)
1315     {
1316         return this.getSuperStrutsActionState().translateConstraint(name, translation);
1317     }
1318 
1319     /**
1320      * Translates all constraints belonging to this model element with the given 'translation'.
1321      * @see ModelElementFacade#translateConstraints(String translation)
1322      */
1323     public String[] translateConstraints(String translation)
1324     {
1325         return this.getSuperStrutsActionState().translateConstraints(translation);
1326     }
1327 
1328     /**
1329      * Translates the constraints of the specified 'kind' belonging to this model element.
1330      * @see ModelElementFacade#translateConstraints(String kind, String translation)
1331      */
1332     public String[] translateConstraints(String kind, String translation)
1333     {
1334         return this.getSuperStrutsActionState().translateConstraints(kind, translation);
1335     }
1336 
1337     /**
1338      * Events to which is being deferred in this action state.
1339      * @see StateFacade#getDeferrableEvents()
1340      */
1341     public Collection<EventFacade> getDeferrableEvents()
1342     {
1343         return this.getSuperStrutsActionState().getDeferrableEvents();
1344     }
1345 
1346     /**
1347      * Models a situation during which some (usually implicit) invariant condition holds. The states
1348      * of
1349      * protocol state machines are exposed to the users of their context classifiers. A protocol
1350      * state
1351      * represents an exposed stable situation of its context classifier: when an instance of the
1352      * classifier
1353      * is not processing any operation, users of this instance can always know its state
1354      * configuration.
1355      * @see org.andromda.metafacades.uml.StateVertexFacade#getContainer()
1356      */
1357     public StateFacade getContainer()
1358     {
1359         return this.getSuperStrutsActionState().getContainer();
1360     }
1361 
1362     /**
1363      * A directed relationship between a source vertex and a target vertex. It may be part of a
1364      * compound
1365      * transition, which takes the state machine from one state configuration to another,
1366      * representing the
1367      * complete response of the state machine to an occurrence of an event of a particular type.
1368      * @see org.andromda.metafacades.uml.StateVertexFacade#getIncomings()
1369      */
1370     public Collection<TransitionFacade> getIncomings()
1371     {
1372         return this.getSuperStrutsActionState().getIncomings();
1373     }
1374 
1375     /**
1376      * A directed relationship between a source vertex and a target vertex. It may be part of a
1377      * compound
1378      * transition, which takes the state machine from one state configuration to another,
1379      * representing the
1380      * complete response of the state machine to an occurrence of an event of a particular type.
1381      * @see org.andromda.metafacades.uml.StateVertexFacade#getOutgoings()
1382      */
1383     public Collection<TransitionFacade> getOutgoings()
1384     {
1385         return this.getSuperStrutsActionState().getOutgoings();
1386     }
1387 
1388     /**
1389      * The partition (if any) to which this vertex belongs.
1390      * @see org.andromda.metafacades.uml.StateVertexFacade#getPartition()
1391      */
1392     public PartitionFacade getPartition()
1393     {
1394         return this.getSuperStrutsActionState().getPartition();
1395     }
1396 
1397     /**
1398      * State machines can be used to express the behavior of part of a system. Behavior is modeled
1399      * as a
1400      * traversal of a graph of state nodes interconnected by one or more joined transition arcs that
1401      * are
1402      * triggered by the dispatching of series of (event) occurrences. During this traversal, the
1403      * state
1404      * machine executes a series of activities associated with various elements of the state
1405      * machine.
1406      * @see org.andromda.metafacades.uml.StateVertexFacade#getStateMachine()
1407      */
1408     public StateMachineFacade getStateMachine()
1409     {
1410         return this.getSuperStrutsActionState().getStateMachine();
1411     }
1412 
1413     // ----------- delegates to FrontEndView ------------
1414     /**
1415      * All actions that can be triggered on this view.
1416      * @see FrontEndView#getActions()
1417      */
1418     public List<FrontEndAction> getActions()
1419     {
1420         return this.getSuperFrontEndView().getActions();
1421     }
1422 
1423     /**
1424      * All parameters for each action going out of this view.
1425      * @see FrontEndView#getAllActionParameters()
1426      */
1427     public List<FrontEndParameter> getAllActionParameters()
1428     {
1429         return this.getSuperFrontEndView().getAllActionParameters();
1430     }
1431 
1432     /**
1433      * All fields from all forms on the given view.
1434      * @see FrontEndView#getAllFormFields()
1435      */
1436     public List<FrontEndParameter> getAllFormFields()
1437     {
1438         return this.getSuperFrontEndView().getAllFormFields();
1439     }
1440 
1441     /**
1442      * All tables belonging to the front end view.
1443      * @see FrontEndView#getTables()
1444      */
1445     public List<FrontEndParameter> getTables()
1446     {
1447         return this.getSuperFrontEndView().getTables();
1448     }
1449 
1450     /**
1451      * The use-case of which this view is a member.
1452      * @see FrontEndView#getUseCase()
1453      */
1454     public FrontEndUseCase getUseCase()
1455     {
1456         return this.getSuperFrontEndView().getUseCase();
1457     }
1458 
1459     /**
1460      * All those variables that will be present as variables in the target view. These are the
1461      * trigger parameters on the incoming transitions.
1462      * @see FrontEndView#getVariables()
1463      */
1464     public List<FrontEndParameter> getVariables()
1465     {
1466         return this.getSuperFrontEndView().getVariables();
1467     }
1468 
1469     /**
1470      * True if this element carries the FrontEndView stereotype.
1471      * @see FrontEndView#isFrontEndView()
1472      */
1473     public boolean isFrontEndView()
1474     {
1475         return this.getSuperFrontEndView().isFrontEndView();
1476     }
1477 
1478     /**
1479      * @see org.andromda.core.metafacade.MetafacadeBase#initialize()
1480      */
1481     @Override
1482     public void initialize()
1483     {
1484         this.getSuperStrutsActionState().initialize();
1485         this.getSuperFrontEndView().initialize();
1486     }
1487 
1488     /**
1489      * @return Object getSuperStrutsActionState().getValidationOwner()
1490      * @see org.andromda.core.metafacade.MetafacadeBase#getValidationOwner()
1491      */
1492     @Override
1493     public Object getValidationOwner()
1494     {
1495         Object owner = this.getSuperStrutsActionState().getValidationOwner();
1496         if (owner == null)
1497         {
1498             owner = this.getSuperFrontEndView().getValidationOwner();
1499         }
1500         return owner;
1501     }
1502 
1503     /**
1504      * @return String getSuperStrutsActionState().getValidationName()
1505      * @see org.andromda.core.metafacade.MetafacadeBase#getValidationName()
1506      */
1507     @Override
1508     public String getValidationName()
1509     {
1510         String name = this.getSuperStrutsActionState().getValidationName();
1511         if (name == null)
1512         {
1513             name = this.getSuperFrontEndView().getValidationName();
1514         }
1515         return name;
1516     }
1517 
1518     /**
1519      * @param validationMessages Collection<ModelValidationMessage>
1520      * @see org.andromda.core.metafacade.MetafacadeBase#validateInvariants(Collection validationMessages)
1521      */
1522     @Override
1523     public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
1524     {
1525         this.getSuperStrutsActionState().validateInvariants(validationMessages);
1526         this.getSuperFrontEndView().validateInvariants(validationMessages);
1527     }
1528 
1529     /**
1530      * The property that stores the name of the metafacade.
1531      */
1532     private static final String NAME_PROPERTY = "name";
1533     private static final String FQNAME_PROPERTY = "fullyQualifiedName";
1534 
1535     /**
1536      * @see Object#toString()
1537      */
1538     @Override
1539     public String toString()
1540     {
1541         final StringBuilder toString = new StringBuilder(this.getClass().getName());
1542         toString.append("[");
1543         try
1544         {
1545             toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY));
1546         }
1547         catch (final Throwable tryAgain)
1548         {
1549             try
1550             {
1551                 toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY));
1552             }
1553             catch (final Throwable ignore)
1554             {
1555                 // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property
1556             }
1557         }
1558         toString.append("]");
1559         return toString.toString();
1560     }
1561 }