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.ClassifierFacade;
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.FrontEndControllerOperation;
19  import org.andromda.metafacades.uml.FrontEndParameter;
20  import org.andromda.metafacades.uml.FrontEndView;
21  import org.andromda.metafacades.uml.ModelElementFacade;
22  import org.andromda.metafacades.uml.ModelFacade;
23  import org.andromda.metafacades.uml.OperationFacade;
24  import org.andromda.metafacades.uml.PackageFacade;
25  import org.andromda.metafacades.uml.StateMachineFacade;
26  import org.andromda.metafacades.uml.StereotypeFacade;
27  import org.andromda.metafacades.uml.TaggedValueFacade;
28  import org.andromda.metafacades.uml.TemplateParameterFacade;
29  import org.andromda.metafacades.uml.TypeMappings;
30  import org.andromda.translation.ocl.validation.OCLCollections;
31  import org.andromda.translation.ocl.validation.OCLExpressions;
32  import org.andromda.translation.ocl.validation.OCLIntrospector;
33  import org.andromda.translation.ocl.validation.OCLResultEnsurer;
34  import org.apache.commons.collections.Predicate;
35  import org.apache.log4j.Logger;
36  
37  /**
38   * A Struts parameter is an object communicated between the client and the server. Typically form
39   * beans encapsulate such parameters.
40   * MetafacadeLogic for StrutsParameter
41   *
42   * @see StrutsParameter
43   */
44  public abstract class StrutsParameterLogic
45      extends MetafacadeBase
46      implements StrutsParameter
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 StrutsParameterLogic(Object metaObjectIn, String context)
59      {
60          super(metaObjectIn, getContext(context));
61          this.superFrontEndParameter =
62             (FrontEndParameter)
63              MetafacadeFactory.getInstance().createFacadeImpl(
64                      "org.andromda.metafacades.uml.FrontEndParameter",
65                      metaObjectIn,
66                      getContext(context));
67          this.metaObject = metaObjectIn;
68      }
69  
70      /**
71       * The logger instance.
72       */
73      private static final Logger logger = Logger.getLogger(StrutsParameterLogic.class);
74  
75      /**
76       * Gets the context for this metafacade logic instance.
77       * @param context String. Set to StrutsParameter if null
78       * @return context String
79       */
80      private static String getContext(String context)
81      {
82          if (context == null)
83          {
84              context = "org.andromda.cartridges.bpm4struts.metafacades.StrutsParameter";
85          }
86          return context;
87      }
88  
89      private FrontEndParameter superFrontEndParameter;
90      private boolean superFrontEndParameterInitialized = false;
91  
92      /**
93       * Gets the FrontEndParameter parent instance.
94       * @return this.superFrontEndParameter FrontEndParameter
95       */
96      private FrontEndParameter getSuperFrontEndParameter()
97      {
98          if (!this.superFrontEndParameterInitialized)
99          {
100             ((MetafacadeBase)this.superFrontEndParameter).setMetafacadeContext(this.getMetafacadeContext());
101             this.superFrontEndParameterInitialized = true;
102         }
103         return this.superFrontEndParameter;
104     }
105 
106     /** Reset context only for non-root metafacades
107      * @param context
108      * @see MetafacadeBase#resetMetafacadeContext(String context)
109      */
110     @Override
111     public void resetMetafacadeContext(String context)
112     {
113         if (!this.contextRoot) // reset context only for non-root metafacades
114         {
115             context = getContext(context);  // to have same value as in original constructor call
116             setMetafacadeContext (context);
117             if (this.superFrontEndParameterInitialized)
118             {
119                 ((MetafacadeBase)this.superFrontEndParameter).resetMetafacadeContext(context);
120             }
121         }
122     }
123 
124     /**
125      * @return boolean true always
126      * @see StrutsParameter
127      */
128     public boolean isStrutsParameterMetaType()
129     {
130         return true;
131     }
132 
133     // --------------- attributes ---------------------
134 
135    /**
136     * @see StrutsParameter#getMessageKey()
137     * @return String
138     */
139     protected abstract String handleGetMessageKey();
140 
141     private String __messageKey1a;
142     private boolean __messageKey1aSet = false;
143 
144     /**
145      * The default message key for this parameter.
146      * @return (String)handleGetMessageKey()
147      */
148     public final String getMessageKey()
149     {
150         String messageKey1a = this.__messageKey1a;
151         if (!this.__messageKey1aSet)
152         {
153             // messageKey has no pre constraints
154             messageKey1a = handleGetMessageKey();
155             // messageKey has no post constraints
156             this.__messageKey1a = messageKey1a;
157             if (isMetafacadePropertyCachingEnabled())
158             {
159                 this.__messageKey1aSet = true;
160             }
161         }
162         return messageKey1a;
163     }
164 
165    /**
166     * @see StrutsParameter#getMessageValue()
167     * @return String
168     */
169     protected abstract String handleGetMessageValue();
170 
171     private String __messageValue2a;
172     private boolean __messageValue2aSet = false;
173 
174     /**
175      * The default message value for this parameter.
176      * @return (String)handleGetMessageValue()
177      */
178     public final String getMessageValue()
179     {
180         String messageValue2a = this.__messageValue2a;
181         if (!this.__messageValue2aSet)
182         {
183             // messageValue has no pre constraints
184             messageValue2a = handleGetMessageValue();
185             // messageValue has no post constraints
186             this.__messageValue2a = messageValue2a;
187             if (isMetafacadePropertyCachingEnabled())
188             {
189                 this.__messageValue2aSet = true;
190             }
191         }
192         return messageValue2a;
193     }
194 
195    /**
196     * @see StrutsParameter#getTitleKey()
197     * @return String
198     */
199     protected abstract String handleGetTitleKey();
200 
201     private String __titleKey3a;
202     private boolean __titleKey3aSet = false;
203 
204     /**
205      * TODO: Model Documentation for
206      * StrutsParameter.titleKey
207      * @return (String)handleGetTitleKey()
208      */
209     public final String getTitleKey()
210     {
211         String titleKey3a = this.__titleKey3a;
212         if (!this.__titleKey3aSet)
213         {
214             // titleKey has no pre constraints
215             titleKey3a = handleGetTitleKey();
216             // titleKey has no post constraints
217             this.__titleKey3a = titleKey3a;
218             if (isMetafacadePropertyCachingEnabled())
219             {
220                 this.__titleKey3aSet = true;
221             }
222         }
223         return titleKey3a;
224     }
225 
226    /**
227     * @see StrutsParameter#getTitleValue()
228     * @return String
229     */
230     protected abstract String handleGetTitleValue();
231 
232     private String __titleValue4a;
233     private boolean __titleValue4aSet = false;
234 
235     /**
236      * TODO: Model Documentation for
237      * StrutsParameter.titleValue
238      * @return (String)handleGetTitleValue()
239      */
240     public final String getTitleValue()
241     {
242         String titleValue4a = this.__titleValue4a;
243         if (!this.__titleValue4aSet)
244         {
245             // titleValue has no pre constraints
246             titleValue4a = handleGetTitleValue();
247             // titleValue has no post constraints
248             this.__titleValue4a = titleValue4a;
249             if (isMetafacadePropertyCachingEnabled())
250             {
251                 this.__titleValue4aSet = true;
252             }
253         }
254         return titleValue4a;
255     }
256 
257    /**
258     * @see StrutsParameter#isMultiple()
259     * @return boolean
260     */
261     protected abstract boolean handleIsMultiple();
262 
263     private boolean __multiple5a;
264     private boolean __multiple5aSet = false;
265 
266     /**
267      * True if this parameter is either an array type or Collection type.
268      * @return (boolean)handleIsMultiple()
269      */
270     public final boolean isMultiple()
271     {
272         boolean multiple5a = this.__multiple5a;
273         if (!this.__multiple5aSet)
274         {
275             // multiple has no pre constraints
276             multiple5a = handleIsMultiple();
277             // multiple has no post constraints
278             this.__multiple5a = multiple5a;
279             if (isMetafacadePropertyCachingEnabled())
280             {
281                 this.__multiple5aSet = true;
282             }
283         }
284         return multiple5a;
285     }
286 
287    /**
288     * @see StrutsParameter#getBackingListName()
289     * @return String
290     */
291     protected abstract String handleGetBackingListName();
292 
293     private String __backingListName6a;
294     private boolean __backingListName6aSet = false;
295 
296     /**
297      * The backing list name for this parameter. This is useful if you want to be able to select the
298      * parameter value from a list.
299      * @return (String)handleGetBackingListName()
300      */
301     public final String getBackingListName()
302     {
303         String backingListName6a = this.__backingListName6a;
304         if (!this.__backingListName6aSet)
305         {
306             // backingListName has no pre constraints
307             backingListName6a = handleGetBackingListName();
308             // backingListName has no post constraints
309             this.__backingListName6a = backingListName6a;
310             if (isMetafacadePropertyCachingEnabled())
311             {
312                 this.__backingListName6aSet = true;
313             }
314         }
315         return backingListName6a;
316     }
317 
318    /**
319     * @see StrutsParameter#isResetRequired()
320     * @return boolean
321     */
322     protected abstract boolean handleIsResetRequired();
323 
324     private boolean __resetRequired7a;
325     private boolean __resetRequired7aSet = false;
326 
327     /**
328      * True if the value of this parameter must be reset between requests (Struts requires this for
329      * specific types), false otherwise.
330      * @return (boolean)handleIsResetRequired()
331      */
332     public final boolean isResetRequired()
333     {
334         boolean resetRequired7a = this.__resetRequired7a;
335         if (!this.__resetRequired7aSet)
336         {
337             // resetRequired has no pre constraints
338             resetRequired7a = handleIsResetRequired();
339             // resetRequired has no post constraints
340             this.__resetRequired7a = resetRequired7a;
341             if (isMetafacadePropertyCachingEnabled())
342             {
343                 this.__resetRequired7aSet = true;
344             }
345         }
346         return resetRequired7a;
347     }
348 
349    /**
350     * @see StrutsParameter#getNullValue()
351     * @return String
352     */
353     protected abstract String handleGetNullValue();
354 
355     private String __nullValue8a;
356     private boolean __nullValue8aSet = false;
357 
358     /**
359      * The null value for the type of this parameter. For decimals this would be zero, for booleans
360      * this would be 'false', etc...
361      * @return (String)handleGetNullValue()
362      */
363     public final String getNullValue()
364     {
365         String nullValue8a = this.__nullValue8a;
366         if (!this.__nullValue8aSet)
367         {
368             // nullValue has no pre constraints
369             nullValue8a = handleGetNullValue();
370             // nullValue has no post constraints
371             this.__nullValue8a = nullValue8a;
372             if (isMetafacadePropertyCachingEnabled())
373             {
374                 this.__nullValue8aSet = true;
375             }
376         }
377         return nullValue8a;
378     }
379 
380    /**
381     * @see StrutsParameter#getWidgetType()
382     * @return String
383     */
384     protected abstract String handleGetWidgetType();
385 
386     private String __widgetType9a;
387     private boolean __widgetType9aSet = false;
388 
389     /**
390      * The widget type for this parameter, this value is the tagname for the Struts HTML taglib.
391      * This method is useful only when rendering forms.
392      * @return (String)handleGetWidgetType()
393      */
394     public final String getWidgetType()
395     {
396         String widgetType9a = this.__widgetType9a;
397         if (!this.__widgetType9aSet)
398         {
399             // widgetType has no pre constraints
400             widgetType9a = handleGetWidgetType();
401             // widgetType has no post constraints
402             this.__widgetType9a = widgetType9a;
403             if (isMetafacadePropertyCachingEnabled())
404             {
405                 this.__widgetType9aSet = true;
406             }
407         }
408         return widgetType9a;
409     }
410 
411    /**
412     * @see StrutsParameter#getResetValue()
413     * @return String
414     */
415     protected abstract String handleGetResetValue();
416 
417     private String __resetValue10a;
418     private boolean __resetValue10aSet = false;
419 
420     /**
421      * The reset value for this parameter. The reset value is the non-null value to which this
422      * parameter is set by default between requests, you can use this method to be able to generate
423      * an application that will deploy and run with default data.
424      * @return (String)handleGetResetValue()
425      */
426     public final String getResetValue()
427     {
428         String resetValue10a = this.__resetValue10a;
429         if (!this.__resetValue10aSet)
430         {
431             // resetValue has no pre constraints
432             resetValue10a = handleGetResetValue();
433             // resetValue has no post constraints
434             this.__resetValue10a = resetValue10a;
435             if (isMetafacadePropertyCachingEnabled())
436             {
437                 this.__resetValue10aSet = true;
438             }
439         }
440         return resetValue10a;
441     }
442 
443    /**
444     * @see StrutsParameter#isReadOnly()
445     * @return boolean
446     */
447     protected abstract boolean handleIsReadOnly();
448 
449     private boolean __readOnly11a;
450     private boolean __readOnly11aSet = false;
451 
452     /**
453      * True if this parameter cannot be changed by the user, false otherwise.
454      * @return (boolean)handleIsReadOnly()
455      */
456     public final boolean isReadOnly()
457     {
458         boolean readOnly11a = this.__readOnly11a;
459         if (!this.__readOnly11aSet)
460         {
461             // readOnly has no pre constraints
462             readOnly11a = handleIsReadOnly();
463             // readOnly has no post constraints
464             this.__readOnly11a = readOnly11a;
465             if (isMetafacadePropertyCachingEnabled())
466             {
467                 this.__readOnly11aSet = true;
468             }
469         }
470         return readOnly11a;
471     }
472 
473    /**
474     * @see StrutsParameter#getValueListResetValue()
475     * @return String
476     */
477     protected abstract String handleGetValueListResetValue();
478 
479     private String __valueListResetValue12a;
480     private boolean __valueListResetValue12aSet = false;
481 
482     /**
483      * The reset value for this parameter's value list. Only makes sense if this parameter is
484      * selectable.
485      * @return (String)handleGetValueListResetValue()
486      */
487     public final String getValueListResetValue()
488     {
489         String valueListResetValue12a = this.__valueListResetValue12a;
490         if (!this.__valueListResetValue12aSet)
491         {
492             // valueListResetValue has no pre constraints
493             valueListResetValue12a = handleGetValueListResetValue();
494             // valueListResetValue has no post constraints
495             this.__valueListResetValue12a = valueListResetValue12a;
496             if (isMetafacadePropertyCachingEnabled())
497             {
498                 this.__valueListResetValue12aSet = true;
499             }
500         }
501         return valueListResetValue12a;
502     }
503 
504    /**
505     * @see StrutsParameter#getValidatorTypes()
506     * @return Collection
507     */
508     protected abstract Collection handleGetValidatorTypes();
509 
510     private Collection __validatorTypes13a;
511     private boolean __validatorTypes13aSet = false;
512 
513     /**
514      * A collection of all the validator types for this parameter. Use this value in conjunction
515      * with the Struts validator plugin.
516      * @return (Collection)handleGetValidatorTypes()
517      */
518     public final Collection getValidatorTypes()
519     {
520         Collection validatorTypes13a = this.__validatorTypes13a;
521         if (!this.__validatorTypes13aSet)
522         {
523             // validatorTypes has no pre constraints
524             validatorTypes13a = handleGetValidatorTypes();
525             // validatorTypes has no post constraints
526             this.__validatorTypes13a = validatorTypes13a;
527             if (isMetafacadePropertyCachingEnabled())
528             {
529                 this.__validatorTypes13aSet = true;
530             }
531         }
532         return validatorTypes13a;
533     }
534 
535    /**
536     * @see StrutsParameter#getValidatorMsgKey()
537     * @return String
538     */
539     protected abstract String handleGetValidatorMsgKey();
540 
541     private String __validatorMsgKey14a;
542     private boolean __validatorMsgKey14aSet = false;
543 
544     /**
545      * The message key for this parameter, equivalent to getMessageKey().
546      * @return (String)handleGetValidatorMsgKey()
547      */
548     public final String getValidatorMsgKey()
549     {
550         String validatorMsgKey14a = this.__validatorMsgKey14a;
551         if (!this.__validatorMsgKey14aSet)
552         {
553             // validatorMsgKey has no pre constraints
554             validatorMsgKey14a = handleGetValidatorMsgKey();
555             // validatorMsgKey has no post constraints
556             this.__validatorMsgKey14a = validatorMsgKey14a;
557             if (isMetafacadePropertyCachingEnabled())
558             {
559                 this.__validatorMsgKey14aSet = true;
560             }
561         }
562         return validatorMsgKey14a;
563     }
564 
565    /**
566     * @see StrutsParameter#getValidatorVars()
567     * @return Collection
568     */
569     protected abstract Collection handleGetValidatorVars();
570 
571     private Collection __validatorVars15a;
572     private boolean __validatorVars15aSet = false;
573 
574     /**
575      * The validator arguments.
576      * @return (Collection)handleGetValidatorVars()
577      */
578     public final Collection getValidatorVars()
579     {
580         Collection validatorVars15a = this.__validatorVars15a;
581         if (!this.__validatorVars15aSet)
582         {
583             // validatorVars has no pre constraints
584             validatorVars15a = handleGetValidatorVars();
585             // validatorVars has no post constraints
586             this.__validatorVars15a = validatorVars15a;
587             if (isMetafacadePropertyCachingEnabled())
588             {
589                 this.__validatorVars15aSet = true;
590             }
591         }
592         return validatorVars15a;
593     }
594 
595    /**
596     * @see StrutsParameter#getValidWhen()
597     * @return String
598     */
599     protected abstract String handleGetValidWhen();
600 
601     private String __validWhen16a;
602     private boolean __validWhen16aSet = false;
603 
604     /**
605      * The validator's 'validwhen' value, this is useful when the validation of a parameter depends
606      * on the validation of others. See the Struts validator plugin documentation for more
607      * information.
608      * @return (String)handleGetValidWhen()
609      */
610     public final String getValidWhen()
611     {
612         String validWhen16a = this.__validWhen16a;
613         if (!this.__validWhen16aSet)
614         {
615             // validWhen has no pre constraints
616             validWhen16a = handleGetValidWhen();
617             // validWhen has no post constraints
618             this.__validWhen16a = validWhen16a;
619             if (isMetafacadePropertyCachingEnabled())
620             {
621                 this.__validWhen16aSet = true;
622             }
623         }
624         return validWhen16a;
625     }
626 
627    /**
628     * @see StrutsParameter#getOptionKeys()
629     * @return List
630     */
631     protected abstract List handleGetOptionKeys();
632 
633     private List __optionKeys17a;
634     private boolean __optionKeys17aSet = false;
635 
636     /**
637      * If this parameter is a choice between radio buttons, then you may use this method to retrieve
638      * the message keys for the resource bundle. The message keys hold the value to be displayed for
639      * the possible options.
640      * @return (List)handleGetOptionKeys()
641      */
642     public final List getOptionKeys()
643     {
644         List optionKeys17a = this.__optionKeys17a;
645         if (!this.__optionKeys17aSet)
646         {
647             // optionKeys has no pre constraints
648             optionKeys17a = handleGetOptionKeys();
649             // optionKeys has no post constraints
650             this.__optionKeys17a = optionKeys17a;
651             if (isMetafacadePropertyCachingEnabled())
652             {
653                 this.__optionKeys17aSet = true;
654             }
655         }
656         return optionKeys17a;
657     }
658 
659    /**
660     * @see StrutsParameter#getTableMaxRows()
661     * @return int
662     */
663     protected abstract int handleGetTableMaxRows();
664 
665     private int __tableMaxRows18a;
666     private boolean __tableMaxRows18aSet = false;
667 
668     /**
669      * The maximum number of rows to be displayed in the table at the same time. This is also known
670      * as the page size. A value of zero or less will display all data in the same table (therefore
671      * also on the same page).
672      * @return (int)handleGetTableMaxRows()
673      */
674     public final int getTableMaxRows()
675     {
676         int tableMaxRows18a = this.__tableMaxRows18a;
677         if (!this.__tableMaxRows18aSet)
678         {
679             // tableMaxRows has no pre constraints
680             tableMaxRows18a = handleGetTableMaxRows();
681             // tableMaxRows has no post constraints
682             this.__tableMaxRows18a = tableMaxRows18a;
683             if (isMetafacadePropertyCachingEnabled())
684             {
685                 this.__tableMaxRows18aSet = true;
686             }
687         }
688         return tableMaxRows18a;
689     }
690 
691    /**
692     * @see StrutsParameter#isTableExportable()
693     * @return boolean
694     */
695     protected abstract boolean handleIsTableExportable();
696 
697     private boolean __tableExportable19a;
698     private boolean __tableExportable19aSet = false;
699 
700     /**
701      * True if it is possible to export the table data to XML, CSV, PDF or Excel format.
702      * @return (boolean)handleIsTableExportable()
703      */
704     public final boolean isTableExportable()
705     {
706         boolean tableExportable19a = this.__tableExportable19a;
707         if (!this.__tableExportable19aSet)
708         {
709             // tableExportable has no pre constraints
710             tableExportable19a = handleIsTableExportable();
711             // tableExportable has no post constraints
712             this.__tableExportable19a = tableExportable19a;
713             if (isMetafacadePropertyCachingEnabled())
714             {
715                 this.__tableExportable19aSet = true;
716             }
717         }
718         return tableExportable19a;
719     }
720 
721    /**
722     * @see StrutsParameter#isTableSortable()
723     * @return boolean
724     */
725     protected abstract boolean handleIsTableSortable();
726 
727     private boolean __tableSortable20a;
728     private boolean __tableSortable20aSet = false;
729 
730     /**
731      * True if it is possible to sort the columns of the table.
732      * @return (boolean)handleIsTableSortable()
733      */
734     public final boolean isTableSortable()
735     {
736         boolean tableSortable20a = this.__tableSortable20a;
737         if (!this.__tableSortable20aSet)
738         {
739             // tableSortable has no pre constraints
740             tableSortable20a = handleIsTableSortable();
741             // tableSortable has no post constraints
742             this.__tableSortable20a = tableSortable20a;
743             if (isMetafacadePropertyCachingEnabled())
744             {
745                 this.__tableSortable20aSet = true;
746             }
747         }
748         return tableSortable20a;
749     }
750 
751    /**
752     * @see StrutsParameter#getTableExportTypes()
753     * @return String
754     */
755     protected abstract String handleGetTableExportTypes();
756 
757     private String __tableExportTypes21a;
758     private boolean __tableExportTypes21aSet = false;
759 
760     /**
761      * Tthe available types of export in a single String instance.
762      * @return (String)handleGetTableExportTypes()
763      */
764     public final String getTableExportTypes()
765     {
766         String tableExportTypes21a = this.__tableExportTypes21a;
767         if (!this.__tableExportTypes21aSet)
768         {
769             // tableExportTypes has no pre constraints
770             tableExportTypes21a = handleGetTableExportTypes();
771             // tableExportTypes has no post constraints
772             this.__tableExportTypes21a = tableExportTypes21a;
773             if (isMetafacadePropertyCachingEnabled())
774             {
775                 this.__tableExportTypes21aSet = true;
776             }
777         }
778         return tableExportTypes21a;
779     }
780 
781    /**
782     * @see StrutsParameter#isValidationRequired()
783     * @return boolean
784     */
785     protected abstract boolean handleIsValidationRequired();
786 
787     private boolean __validationRequired22a;
788     private boolean __validationRequired22aSet = false;
789 
790     /**
791      * True if this parameter requires some kind of validation. This means the collection of
792      * validator types is not empty.
793      * @return (boolean)handleIsValidationRequired()
794      */
795     public final boolean isValidationRequired()
796     {
797         boolean validationRequired22a = this.__validationRequired22a;
798         if (!this.__validationRequired22aSet)
799         {
800             // validationRequired has no pre constraints
801             validationRequired22a = handleIsValidationRequired();
802             // validationRequired has no post constraints
803             this.__validationRequired22a = validationRequired22a;
804             if (isMetafacadePropertyCachingEnabled())
805             {
806                 this.__validationRequired22aSet = true;
807             }
808         }
809         return validationRequired22a;
810     }
811 
812    /**
813     * @see StrutsParameter#isDate()
814     * @return boolean
815     */
816     protected abstract boolean handleIsDate();
817 
818     private boolean __date23a;
819     private boolean __date23aSet = false;
820 
821     /**
822      * True if the type of this parameter represents a date. This is equivalent to
823      * parameter.type.isDateType().
824      * @return (boolean)handleIsDate()
825      */
826     public final boolean isDate()
827     {
828         boolean date23a = this.__date23a;
829         if (!this.__date23aSet)
830         {
831             // date has no pre constraints
832             date23a = handleIsDate();
833             // date has no post constraints
834             this.__date23a = date23a;
835             if (isMetafacadePropertyCachingEnabled())
836             {
837                 this.__date23aSet = true;
838             }
839         }
840         return date23a;
841     }
842 
843    /**
844     * @see StrutsParameter#getDateFormat()
845     * @return String
846     */
847     protected abstract String handleGetDateFormat();
848 
849     private String __dateFormat24a;
850     private boolean __dateFormat24aSet = false;
851 
852     /**
853      * If this parameter represents a date this method will return the format in which it must be
854      * represented. In case this format has not been specified by the any tagged value a default one
855      * will be taken.
856      * @return (String)handleGetDateFormat()
857      */
858     public final String getDateFormat()
859     {
860         String dateFormat24a = this.__dateFormat24a;
861         if (!this.__dateFormat24aSet)
862         {
863             // dateFormat has no pre constraints
864             dateFormat24a = handleGetDateFormat();
865             // dateFormat has no post constraints
866             this.__dateFormat24a = dateFormat24a;
867             if (isMetafacadePropertyCachingEnabled())
868             {
869                 this.__dateFormat24aSet = true;
870             }
871         }
872         return dateFormat24a;
873     }
874 
875    /**
876     * @see StrutsParameter#isStrictDateFormat()
877     * @return boolean
878     */
879     protected abstract boolean handleIsStrictDateFormat();
880 
881     private boolean __strictDateFormat25a;
882     private boolean __strictDateFormat25aSet = false;
883 
884     /**
885      * True if the date format is to be strictly respected. Otherwise the dateformatter used for the
886      * representation of this date is to be set to lenient.
887      * @return (boolean)handleIsStrictDateFormat()
888      */
889     public final boolean isStrictDateFormat()
890     {
891         boolean strictDateFormat25a = this.__strictDateFormat25a;
892         if (!this.__strictDateFormat25aSet)
893         {
894             // strictDateFormat has no pre constraints
895             strictDateFormat25a = handleIsStrictDateFormat();
896             // strictDateFormat has no post constraints
897             this.__strictDateFormat25a = strictDateFormat25a;
898             if (isMetafacadePropertyCachingEnabled())
899             {
900                 this.__strictDateFormat25aSet = true;
901             }
902         }
903         return strictDateFormat25a;
904     }
905 
906    /**
907     * @see StrutsParameter#isCalendarRequired()
908     * @return boolean
909     */
910     protected abstract boolean handleIsCalendarRequired();
911 
912     private boolean __calendarRequired26a;
913     private boolean __calendarRequired26aSet = false;
914 
915     /**
916      * True if this parameter is a date and it requires a calendar popup.
917      * @return (boolean)handleIsCalendarRequired()
918      */
919     public final boolean isCalendarRequired()
920     {
921         boolean calendarRequired26a = this.__calendarRequired26a;
922         if (!this.__calendarRequired26aSet)
923         {
924             // calendarRequired has no pre constraints
925             calendarRequired26a = handleIsCalendarRequired();
926             // calendarRequired has no post constraints
927             this.__calendarRequired26a = calendarRequired26a;
928             if (isMetafacadePropertyCachingEnabled())
929             {
930                 this.__calendarRequired26aSet = true;
931             }
932         }
933         return calendarRequired26a;
934     }
935 
936    /**
937     * @see StrutsParameter#getTableDecoratorPackageName()
938     * @return String
939     */
940     protected abstract String handleGetTableDecoratorPackageName();
941 
942     private String __tableDecoratorPackageName27a;
943     private boolean __tableDecoratorPackageName27aSet = false;
944 
945     /**
946      * The package name of the decorator to use for the table.
947      * @return (String)handleGetTableDecoratorPackageName()
948      */
949     public final String getTableDecoratorPackageName()
950     {
951         String tableDecoratorPackageName27a = this.__tableDecoratorPackageName27a;
952         if (!this.__tableDecoratorPackageName27aSet)
953         {
954             // tableDecoratorPackageName has no pre constraints
955             tableDecoratorPackageName27a = handleGetTableDecoratorPackageName();
956             // tableDecoratorPackageName has no post constraints
957             this.__tableDecoratorPackageName27a = tableDecoratorPackageName27a;
958             if (isMetafacadePropertyCachingEnabled())
959             {
960                 this.__tableDecoratorPackageName27aSet = true;
961             }
962         }
963         return tableDecoratorPackageName27a;
964     }
965 
966    /**
967     * @see StrutsParameter#getTableDecoratorClassName()
968     * @return String
969     */
970     protected abstract String handleGetTableDecoratorClassName();
971 
972     private String __tableDecoratorClassName28a;
973     private boolean __tableDecoratorClassName28aSet = false;
974 
975     /**
976      * The class name of the decorator to use for the table.
977      * @return (String)handleGetTableDecoratorClassName()
978      */
979     public final String getTableDecoratorClassName()
980     {
981         String tableDecoratorClassName28a = this.__tableDecoratorClassName28a;
982         if (!this.__tableDecoratorClassName28aSet)
983         {
984             // tableDecoratorClassName has no pre constraints
985             tableDecoratorClassName28a = handleGetTableDecoratorClassName();
986             // tableDecoratorClassName has no post constraints
987             this.__tableDecoratorClassName28a = tableDecoratorClassName28a;
988             if (isMetafacadePropertyCachingEnabled())
989             {
990                 this.__tableDecoratorClassName28aSet = true;
991             }
992         }
993         return tableDecoratorClassName28a;
994     }
995 
996    /**
997     * @see StrutsParameter#getTableDecoratorFullPath()
998     * @return String
999     */
1000     protected abstract String handleGetTableDecoratorFullPath();
1001 
1002     private String __tableDecoratorFullPath29a;
1003     private boolean __tableDecoratorFullPath29aSet = false;
1004 
1005     /**
1006      * The full path to the decorator class.
1007      * @return (String)handleGetTableDecoratorFullPath()
1008      */
1009     public final String getTableDecoratorFullPath()
1010     {
1011         String tableDecoratorFullPath29a = this.__tableDecoratorFullPath29a;
1012         if (!this.__tableDecoratorFullPath29aSet)
1013         {
1014             // tableDecoratorFullPath has no pre constraints
1015             tableDecoratorFullPath29a = handleGetTableDecoratorFullPath();
1016             // tableDecoratorFullPath has no post constraints
1017             this.__tableDecoratorFullPath29a = tableDecoratorFullPath29a;
1018             if (isMetafacadePropertyCachingEnabled())
1019             {
1020                 this.__tableDecoratorFullPath29aSet = true;
1021             }
1022         }
1023         return tableDecoratorFullPath29a;
1024     }
1025 
1026    /**
1027     * @see StrutsParameter#getOptionValues()
1028     * @return List
1029     */
1030     protected abstract List handleGetOptionValues();
1031 
1032     private List __optionValues30a;
1033     private boolean __optionValues30aSet = false;
1034 
1035     /**
1036      * The values for the options. Only makes sense when the widget type is radiobutton. The
1037      * property value may directly be specified usiing the tagged value.
1038      * @return (List)handleGetOptionValues()
1039      */
1040     public final List getOptionValues()
1041     {
1042         List optionValues30a = this.__optionValues30a;
1043         if (!this.__optionValues30aSet)
1044         {
1045             // optionValues has no pre constraints
1046             optionValues30a = handleGetOptionValues();
1047             // optionValues has no post constraints
1048             this.__optionValues30a = optionValues30a;
1049             if (isMetafacadePropertyCachingEnabled())
1050             {
1051                 this.__optionValues30aSet = true;
1052             }
1053         }
1054         return optionValues30a;
1055     }
1056 
1057    /**
1058     * @see StrutsParameter#getOptionCount()
1059     * @return int
1060     */
1061     protected abstract int handleGetOptionCount();
1062 
1063     private int __optionCount31a;
1064     private boolean __optionCount31aSet = false;
1065 
1066     /**
1067      * In case this parameter represents an option set using radiobuttons, this attribute is a
1068      * positive integer and zero otherwise.
1069      * @return (int)handleGetOptionCount()
1070      */
1071     public final int getOptionCount()
1072     {
1073         int optionCount31a = this.__optionCount31a;
1074         if (!this.__optionCount31aSet)
1075         {
1076             // optionCount has no pre constraints
1077             optionCount31a = handleGetOptionCount();
1078             // optionCount has no post constraints
1079             this.__optionCount31a = optionCount31a;
1080             if (isMetafacadePropertyCachingEnabled())
1081             {
1082                 this.__optionCount31aSet = true;
1083             }
1084         }
1085         return optionCount31a;
1086     }
1087 
1088    /**
1089     * @see StrutsParameter#getDocumentationKey()
1090     * @return String
1091     */
1092     protected abstract String handleGetDocumentationKey();
1093 
1094     private String __documentationKey32a;
1095     private boolean __documentationKey32aSet = false;
1096 
1097     /**
1098      * The key to lookup the documentation for this parameter.
1099      * @return (String)handleGetDocumentationKey()
1100      */
1101     public final String getDocumentationKey()
1102     {
1103         String documentationKey32a = this.__documentationKey32a;
1104         if (!this.__documentationKey32aSet)
1105         {
1106             // documentationKey has no pre constraints
1107             documentationKey32a = handleGetDocumentationKey();
1108             // documentationKey has no post constraints
1109             this.__documentationKey32a = documentationKey32a;
1110             if (isMetafacadePropertyCachingEnabled())
1111             {
1112                 this.__documentationKey32aSet = true;
1113             }
1114         }
1115         return documentationKey32a;
1116     }
1117 
1118    /**
1119     * @see StrutsParameter#getDocumentationValue()
1120     * @return String
1121     */
1122     protected abstract String handleGetDocumentationValue();
1123 
1124     private String __documentationValue33a;
1125     private boolean __documentationValue33aSet = false;
1126 
1127     /**
1128      * The documentation for this parameter, formatted to be inserted into a resource bundle.
1129      * @return (String)handleGetDocumentationValue()
1130      */
1131     public final String getDocumentationValue()
1132     {
1133         String documentationValue33a = this.__documentationValue33a;
1134         if (!this.__documentationValue33aSet)
1135         {
1136             // documentationValue has no pre constraints
1137             documentationValue33a = handleGetDocumentationValue();
1138             // documentationValue has no post constraints
1139             this.__documentationValue33a = documentationValue33a;
1140             if (isMetafacadePropertyCachingEnabled())
1141             {
1142                 this.__documentationValue33aSet = true;
1143             }
1144         }
1145         return documentationValue33a;
1146     }
1147 
1148    /**
1149     * @see StrutsParameter#getOnlineHelpKey()
1150     * @return String
1151     */
1152     protected abstract String handleGetOnlineHelpKey();
1153 
1154     private String __onlineHelpKey34a;
1155     private boolean __onlineHelpKey34aSet = false;
1156 
1157     /**
1158      * The key to lookup the online help documentation. This documentation is gathered from the
1159      * documentation entered by the user, as well as analyzing the model.
1160      * @return (String)handleGetOnlineHelpKey()
1161      */
1162     public final String getOnlineHelpKey()
1163     {
1164         String onlineHelpKey34a = this.__onlineHelpKey34a;
1165         if (!this.__onlineHelpKey34aSet)
1166         {
1167             // onlineHelpKey has no pre constraints
1168             onlineHelpKey34a = handleGetOnlineHelpKey();
1169             // onlineHelpKey has no post constraints
1170             this.__onlineHelpKey34a = onlineHelpKey34a;
1171             if (isMetafacadePropertyCachingEnabled())
1172             {
1173                 this.__onlineHelpKey34aSet = true;
1174             }
1175         }
1176         return onlineHelpKey34a;
1177     }
1178 
1179    /**
1180     * @see StrutsParameter#getOnlineHelpValue()
1181     * @return String
1182     */
1183     protected abstract String handleGetOnlineHelpValue();
1184 
1185     private String __onlineHelpValue35a;
1186     private boolean __onlineHelpValue35aSet = false;
1187 
1188     /**
1189      * The online help documentation. This documentation is gathered from the documentation entered
1190      * by the user, as well as analyzing the model. The format is HTML without any style.
1191      * @return (String)handleGetOnlineHelpValue()
1192      */
1193     public final String getOnlineHelpValue()
1194     {
1195         String onlineHelpValue35a = this.__onlineHelpValue35a;
1196         if (!this.__onlineHelpValue35aSet)
1197         {
1198             // onlineHelpValue has no pre constraints
1199             onlineHelpValue35a = handleGetOnlineHelpValue();
1200             // onlineHelpValue has no post constraints
1201             this.__onlineHelpValue35a = onlineHelpValue35a;
1202             if (isMetafacadePropertyCachingEnabled())
1203             {
1204                 this.__onlineHelpValue35aSet = true;
1205             }
1206         }
1207         return onlineHelpValue35a;
1208     }
1209 
1210    /**
1211     * @see StrutsParameter#isSelectable()
1212     * @return boolean
1213     */
1214     protected abstract boolean handleIsSelectable();
1215 
1216     private boolean __selectable36a;
1217     private boolean __selectable36aSet = false;
1218 
1219     /**
1220      * Whether or not this parameter is selectable. In case this would be true this parameter always
1221      * has a backing list, a value list and a list containing the labels.
1222      * @return (boolean)handleIsSelectable()
1223      */
1224     public final boolean isSelectable()
1225     {
1226         boolean selectable36a = this.__selectable36a;
1227         if (!this.__selectable36aSet)
1228         {
1229             // selectable has no pre constraints
1230             selectable36a = handleIsSelectable();
1231             // selectable has no post constraints
1232             this.__selectable36a = selectable36a;
1233             if (isMetafacadePropertyCachingEnabled())
1234             {
1235                 this.__selectable36aSet = true;
1236             }
1237         }
1238         return selectable36a;
1239     }
1240 
1241    /**
1242     * @see StrutsParameter#getValueListName()
1243     * @return String
1244     */
1245     protected abstract String handleGetValueListName();
1246 
1247     private String __valueListName37a;
1248     private boolean __valueListName37aSet = false;
1249 
1250     /**
1251      * The name of the list holding the values for this parameter. Only makes sense when the
1252      * parameter is selectable.
1253      * @return (String)handleGetValueListName()
1254      */
1255     public final String getValueListName()
1256     {
1257         String valueListName37a = this.__valueListName37a;
1258         if (!this.__valueListName37aSet)
1259         {
1260             // valueListName has no pre constraints
1261             valueListName37a = handleGetValueListName();
1262             // valueListName has no post constraints
1263             this.__valueListName37a = valueListName37a;
1264             if (isMetafacadePropertyCachingEnabled())
1265             {
1266                 this.__valueListName37aSet = true;
1267             }
1268         }
1269         return valueListName37a;
1270     }
1271 
1272    /**
1273     * @see StrutsParameter#getLabelListName()
1274     * @return String
1275     */
1276     protected abstract String handleGetLabelListName();
1277 
1278     private String __labelListName38a;
1279     private boolean __labelListName38aSet = false;
1280 
1281     /**
1282      * The name of the list holding the labels for this parameter. Only makes sense when the
1283      * parameter is selectable.
1284      * @return (String)handleGetLabelListName()
1285      */
1286     public final String getLabelListName()
1287     {
1288         String labelListName38a = this.__labelListName38a;
1289         if (!this.__labelListName38aSet)
1290         {
1291             // labelListName has no pre constraints
1292             labelListName38a = handleGetLabelListName();
1293             // labelListName has no post constraints
1294             this.__labelListName38a = labelListName38a;
1295             if (isMetafacadePropertyCachingEnabled())
1296             {
1297                 this.__labelListName38aSet = true;
1298             }
1299         }
1300         return labelListName38a;
1301     }
1302 
1303    /**
1304     * @see StrutsParameter#getCollectionImplementationType()
1305     * @return String
1306     */
1307     protected abstract String handleGetCollectionImplementationType();
1308 
1309     private String __collectionImplementationType39a;
1310     private boolean __collectionImplementationType39aSet = false;
1311 
1312     /**
1313      * If this parameter is a collection type, this property will represent the fully qualified name
1314      * of a class suitable for implementation. If the type is neither Collection, List, nor Set the
1315      * type itself is assumed.
1316      * @return (String)handleGetCollectionImplementationType()
1317      */
1318     public final String getCollectionImplementationType()
1319     {
1320         String collectionImplementationType39a = this.__collectionImplementationType39a;
1321         if (!this.__collectionImplementationType39aSet)
1322         {
1323             // collectionImplementationType has no pre constraints
1324             collectionImplementationType39a = handleGetCollectionImplementationType();
1325             // collectionImplementationType has no post constraints
1326             this.__collectionImplementationType39a = collectionImplementationType39a;
1327             if (isMetafacadePropertyCachingEnabled())
1328             {
1329                 this.__collectionImplementationType39aSet = true;
1330             }
1331         }
1332         return collectionImplementationType39a;
1333     }
1334 
1335    /**
1336     * @see StrutsParameter#getMultiboxPropertyName()
1337     * @return String
1338     */
1339     protected abstract String handleGetMultiboxPropertyName();
1340 
1341     private String __multiboxPropertyName40a;
1342     private boolean __multiboxPropertyName40aSet = false;
1343 
1344     /**
1345      * The name of the array to be used for the multibox, this only makes sense when this parameter
1346      * is actually a multibox.
1347      * @return (String)handleGetMultiboxPropertyName()
1348      */
1349     public final String getMultiboxPropertyName()
1350     {
1351         String multiboxPropertyName40a = this.__multiboxPropertyName40a;
1352         if (!this.__multiboxPropertyName40aSet)
1353         {
1354             // multiboxPropertyName has no pre constraints
1355             multiboxPropertyName40a = handleGetMultiboxPropertyName();
1356             // multiboxPropertyName has no post constraints
1357             this.__multiboxPropertyName40a = multiboxPropertyName40a;
1358             if (isMetafacadePropertyCachingEnabled())
1359             {
1360                 this.__multiboxPropertyName40aSet = true;
1361             }
1362         }
1363         return multiboxPropertyName40a;
1364     }
1365 
1366    /**
1367     * @see StrutsParameter#isShouldReset()
1368     * @return boolean
1369     */
1370     protected abstract boolean handleIsShouldReset();
1371 
1372     private boolean __shouldReset41a;
1373     private boolean __shouldReset41aSet = false;
1374 
1375     /**
1376      * Whether or not this parameter should be reset between requests.  This is different than
1377      * resetRequired in that this is user specified.
1378      * @return (boolean)handleIsShouldReset()
1379      */
1380     public final boolean isShouldReset()
1381     {
1382         boolean shouldReset41a = this.__shouldReset41a;
1383         if (!this.__shouldReset41aSet)
1384         {
1385             // shouldReset has no pre constraints
1386             shouldReset41a = handleIsShouldReset();
1387             // shouldReset has no post constraints
1388             this.__shouldReset41a = shouldReset41a;
1389             if (isMetafacadePropertyCachingEnabled())
1390             {
1391                 this.__shouldReset41aSet = true;
1392             }
1393         }
1394         return shouldReset41a;
1395     }
1396 
1397    /**
1398     * @see StrutsParameter#getResetName()
1399     * @return String
1400     */
1401     protected abstract String handleGetResetName();
1402 
1403     private String __resetName42a;
1404     private boolean __resetName42aSet = false;
1405 
1406     /**
1407      * The name of the operation that resets this parameter to its original value.
1408      * @return (String)handleGetResetName()
1409      */
1410     public final String getResetName()
1411     {
1412         String resetName42a = this.__resetName42a;
1413         if (!this.__resetName42aSet)
1414         {
1415             // resetName has no pre constraints
1416             resetName42a = handleGetResetName();
1417             // resetName has no post constraints
1418             this.__resetName42a = resetName42a;
1419             if (isMetafacadePropertyCachingEnabled())
1420             {
1421                 this.__resetName42aSet = true;
1422             }
1423         }
1424         return resetName42a;
1425     }
1426 
1427    /**
1428     * @see StrutsParameter#isFile()
1429     * @return boolean
1430     */
1431     protected abstract boolean handleIsFile();
1432 
1433     private boolean __file43a;
1434     private boolean __file43aSet = false;
1435 
1436     /**
1437      * TODO: Model Documentation for
1438      * StrutsParameter.file
1439      * @return (boolean)handleIsFile()
1440      */
1441     public final boolean isFile()
1442     {
1443         boolean file43a = this.__file43a;
1444         if (!this.__file43aSet)
1445         {
1446             // file has no pre constraints
1447             file43a = handleIsFile();
1448             // file has no post constraints
1449             this.__file43a = file43a;
1450             if (isMetafacadePropertyCachingEnabled())
1451             {
1452                 this.__file43aSet = true;
1453             }
1454         }
1455         return file43a;
1456     }
1457 
1458    /**
1459     * @see StrutsParameter#isPassword()
1460     * @return boolean
1461     */
1462     protected abstract boolean handleIsPassword();
1463 
1464     private boolean __password44a;
1465     private boolean __password44aSet = false;
1466 
1467     /**
1468      * True if this parameter represents a password field.
1469      * @return (boolean)handleIsPassword()
1470      */
1471     public final boolean isPassword()
1472     {
1473         boolean password44a = this.__password44a;
1474         if (!this.__password44aSet)
1475         {
1476             // password has no pre constraints
1477             password44a = handleIsPassword();
1478             // password has no post constraints
1479             this.__password44a = password44a;
1480             if (isMetafacadePropertyCachingEnabled())
1481             {
1482                 this.__password44aSet = true;
1483             }
1484         }
1485         return password44a;
1486     }
1487 
1488    /**
1489     * @see StrutsParameter#isTableDecoratorRequired()
1490     * @return boolean
1491     */
1492     protected abstract boolean handleIsTableDecoratorRequired();
1493 
1494     private boolean __tableDecoratorRequired45a;
1495     private boolean __tableDecoratorRequired45aSet = false;
1496 
1497     /**
1498      * TODO: Model Documentation for
1499      * StrutsParameter.tableDecoratorRequired
1500      * @return (boolean)handleIsTableDecoratorRequired()
1501      */
1502     public final boolean isTableDecoratorRequired()
1503     {
1504         boolean tableDecoratorRequired45a = this.__tableDecoratorRequired45a;
1505         if (!this.__tableDecoratorRequired45aSet)
1506         {
1507             // tableDecoratorRequired has no pre constraints
1508             tableDecoratorRequired45a = handleIsTableDecoratorRequired();
1509             // tableDecoratorRequired has no post constraints
1510             this.__tableDecoratorRequired45a = tableDecoratorRequired45a;
1511             if (isMetafacadePropertyCachingEnabled())
1512             {
1513                 this.__tableDecoratorRequired45aSet = true;
1514             }
1515         }
1516         return tableDecoratorRequired45a;
1517     }
1518 
1519    /**
1520     * @see StrutsParameter#getTableDecoratorFullyQualifiedName()
1521     * @return String
1522     */
1523     protected abstract String handleGetTableDecoratorFullyQualifiedName();
1524 
1525     private String __tableDecoratorFullyQualifiedName46a;
1526     private boolean __tableDecoratorFullyQualifiedName46aSet = false;
1527 
1528     /**
1529      * The complete table decorator classname.
1530      * @return (String)handleGetTableDecoratorFullyQualifiedName()
1531      */
1532     public final String getTableDecoratorFullyQualifiedName()
1533     {
1534         String tableDecoratorFullyQualifiedName46a = this.__tableDecoratorFullyQualifiedName46a;
1535         if (!this.__tableDecoratorFullyQualifiedName46aSet)
1536         {
1537             // tableDecoratorFullyQualifiedName has no pre constraints
1538             tableDecoratorFullyQualifiedName46a = handleGetTableDecoratorFullyQualifiedName();
1539             // tableDecoratorFullyQualifiedName has no post constraints
1540             this.__tableDecoratorFullyQualifiedName46a = tableDecoratorFullyQualifiedName46a;
1541             if (isMetafacadePropertyCachingEnabled())
1542             {
1543                 this.__tableDecoratorFullyQualifiedName46aSet = true;
1544             }
1545         }
1546         return tableDecoratorFullyQualifiedName46a;
1547     }
1548 
1549    /**
1550     * @see StrutsParameter#getStyleId()
1551     * @return String
1552     */
1553     protected abstract String handleGetStyleId();
1554 
1555     private String __styleId47a;
1556     private boolean __styleId47aSet = false;
1557 
1558     /**
1559      * TODO: Model Documentation for
1560      * StrutsParameter.styleId
1561      * @return (String)handleGetStyleId()
1562      */
1563     public final String getStyleId()
1564     {
1565         String styleId47a = this.__styleId47a;
1566         if (!this.__styleId47aSet)
1567         {
1568             // styleId has no pre constraints
1569             styleId47a = handleGetStyleId();
1570             // styleId has no post constraints
1571             this.__styleId47a = styleId47a;
1572             if (isMetafacadePropertyCachingEnabled())
1573             {
1574                 this.__styleId47aSet = true;
1575             }
1576         }
1577         return styleId47a;
1578     }
1579 
1580    /**
1581     * @see StrutsParameter#isTableFormActionSharingWidgets()
1582     * @return boolean
1583     */
1584     protected abstract boolean handleIsTableFormActionSharingWidgets();
1585 
1586     private boolean __tableFormActionSharingWidgets48a;
1587     private boolean __tableFormActionSharingWidgets48aSet = false;
1588 
1589     /**
1590      * True if this table has form actions that share the column widgets. It is not allowed to have
1591      * different actions use different widgets on the same column.
1592      * @return (boolean)handleIsTableFormActionSharingWidgets()
1593      */
1594     public final boolean isTableFormActionSharingWidgets()
1595     {
1596         boolean tableFormActionSharingWidgets48a = this.__tableFormActionSharingWidgets48a;
1597         if (!this.__tableFormActionSharingWidgets48aSet)
1598         {
1599             // tableFormActionSharingWidgets has no pre constraints
1600             tableFormActionSharingWidgets48a = handleIsTableFormActionSharingWidgets();
1601             // tableFormActionSharingWidgets has no post constraints
1602             this.__tableFormActionSharingWidgets48a = tableFormActionSharingWidgets48a;
1603             if (isMetafacadePropertyCachingEnabled())
1604             {
1605                 this.__tableFormActionSharingWidgets48aSet = true;
1606             }
1607         }
1608         return tableFormActionSharingWidgets48a;
1609     }
1610 
1611    /**
1612     * @see StrutsParameter#isTableHyperlinkColumn()
1613     * @return boolean
1614     */
1615     protected abstract boolean handleIsTableHyperlinkColumn();
1616 
1617     private boolean __tableHyperlinkColumn49a;
1618     private boolean __tableHyperlinkColumn49aSet = false;
1619 
1620     /**
1621      * True if this parameter represents a table column into which an hyperlink must be rendered.
1622      * This property only makes sense when it has been called on parameters representing an actual
1623      * table column. Note that the getTableColumns() operation also returns String instances.
1624      * @return (boolean)handleIsTableHyperlinkColumn()
1625      */
1626     public final boolean isTableHyperlinkColumn()
1627     {
1628         boolean tableHyperlinkColumn49a = this.__tableHyperlinkColumn49a;
1629         if (!this.__tableHyperlinkColumn49aSet)
1630         {
1631             // tableHyperlinkColumn has no pre constraints
1632             tableHyperlinkColumn49a = handleIsTableHyperlinkColumn();
1633             // tableHyperlinkColumn has no post constraints
1634             this.__tableHyperlinkColumn49a = tableHyperlinkColumn49a;
1635             if (isMetafacadePropertyCachingEnabled())
1636             {
1637                 this.__tableHyperlinkColumn49aSet = true;
1638             }
1639         }
1640         return tableHyperlinkColumn49a;
1641     }
1642 
1643    /**
1644     * @see StrutsParameter#isSortableBy()
1645     * @return boolean
1646     */
1647     protected abstract boolean handleIsSortableBy();
1648 
1649     private boolean __sortableBy50a;
1650     private boolean __sortableBy50aSet = false;
1651 
1652     /**
1653      * Indicates if a table can be sorted by this parameter.
1654      * @return (boolean)handleIsSortableBy()
1655      */
1656     public final boolean isSortableBy()
1657     {
1658         boolean sortableBy50a = this.__sortableBy50a;
1659         if (!this.__sortableBy50aSet)
1660         {
1661             // sortableBy has no pre constraints
1662             sortableBy50a = handleIsSortableBy();
1663             // sortableBy has no post constraints
1664             this.__sortableBy50a = sortableBy50a;
1665             if (isMetafacadePropertyCachingEnabled())
1666             {
1667                 this.__sortableBy50aSet = true;
1668             }
1669         }
1670         return sortableBy50a;
1671     }
1672 
1673    /**
1674     * @see StrutsParameter#getTimeFormat()
1675     * @return String
1676     */
1677     protected abstract String handleGetTimeFormat();
1678 
1679     private String __timeFormat51a;
1680     private boolean __timeFormat51aSet = false;
1681 
1682     /**
1683      * The time format for this parameter (if this parameter stores time).
1684      * @return (String)handleGetTimeFormat()
1685      */
1686     public final String getTimeFormat()
1687     {
1688         String timeFormat51a = this.__timeFormat51a;
1689         if (!this.__timeFormat51aSet)
1690         {
1691             // timeFormat has no pre constraints
1692             timeFormat51a = handleGetTimeFormat();
1693             // timeFormat has no post constraints
1694             this.__timeFormat51a = timeFormat51a;
1695             if (isMetafacadePropertyCachingEnabled())
1696             {
1697                 this.__timeFormat51aSet = true;
1698             }
1699         }
1700         return timeFormat51a;
1701     }
1702 
1703    /**
1704     * @see StrutsParameter#isTime()
1705     * @return boolean
1706     */
1707     protected abstract boolean handleIsTime();
1708 
1709     private boolean __time52a;
1710     private boolean __time52aSet = false;
1711 
1712     /**
1713      * Indicates if this parameter's type represents a time.
1714      * @return (boolean)handleIsTime()
1715      */
1716     public final boolean isTime()
1717     {
1718         boolean time52a = this.__time52a;
1719         if (!this.__time52aSet)
1720         {
1721             // time has no pre constraints
1722             time52a = handleIsTime();
1723             // time has no post constraints
1724             this.__time52a = time52a;
1725             if (isMetafacadePropertyCachingEnabled())
1726             {
1727                 this.__time52aSet = true;
1728             }
1729         }
1730         return time52a;
1731     }
1732 
1733    /**
1734     * @see StrutsParameter#isAllGlobalTableActionsHaveSameParameter()
1735     * @return boolean
1736     */
1737     protected abstract boolean handleIsAllGlobalTableActionsHaveSameParameter();
1738 
1739     private boolean __allGlobalTableActionsHaveSameParameter53a;
1740     private boolean __allGlobalTableActionsHaveSameParameter53aSet = false;
1741 
1742     /**
1743      * This property is used in model validation. It denotes whether all actions targetting this
1744      * table page-variable take the same parameter (same name and type). Only makes sense when this
1745      * parameter is actually a table page-variable.
1746      * @return (boolean)handleIsAllGlobalTableActionsHaveSameParameter()
1747      */
1748     public final boolean isAllGlobalTableActionsHaveSameParameter()
1749     {
1750         boolean allGlobalTableActionsHaveSameParameter53a = this.__allGlobalTableActionsHaveSameParameter53a;
1751         if (!this.__allGlobalTableActionsHaveSameParameter53aSet)
1752         {
1753             // allGlobalTableActionsHaveSameParameter has no pre constraints
1754             allGlobalTableActionsHaveSameParameter53a = handleIsAllGlobalTableActionsHaveSameParameter();
1755             // allGlobalTableActionsHaveSameParameter has no post constraints
1756             this.__allGlobalTableActionsHaveSameParameter53a = allGlobalTableActionsHaveSameParameter53a;
1757             if (isMetafacadePropertyCachingEnabled())
1758             {
1759                 this.__allGlobalTableActionsHaveSameParameter53aSet = true;
1760             }
1761         }
1762         return allGlobalTableActionsHaveSameParameter53a;
1763     }
1764 
1765    /**
1766     * @see StrutsParameter#getFieldRowCount()
1767     * @return Integer
1768     */
1769     protected abstract Integer handleGetFieldRowCount();
1770 
1771     private Integer __fieldRowCount54a;
1772     private boolean __fieldRowCount54aSet = false;
1773 
1774     /**
1775      * The number of rows for this field, null if default browser value is desired.
1776      * @return (Integer)handleGetFieldRowCount()
1777      */
1778     public final Integer getFieldRowCount()
1779     {
1780         Integer fieldRowCount54a = this.__fieldRowCount54a;
1781         if (!this.__fieldRowCount54aSet)
1782         {
1783             // fieldRowCount has no pre constraints
1784             fieldRowCount54a = handleGetFieldRowCount();
1785             // fieldRowCount has no post constraints
1786             this.__fieldRowCount54a = fieldRowCount54a;
1787             if (isMetafacadePropertyCachingEnabled())
1788             {
1789                 this.__fieldRowCount54aSet = true;
1790             }
1791         }
1792         return fieldRowCount54a;
1793     }
1794 
1795    /**
1796     * @see StrutsParameter#getFieldColumnCount()
1797     * @return Integer
1798     */
1799     protected abstract Integer handleGetFieldColumnCount();
1800 
1801     private Integer __fieldColumnCount55a;
1802     private boolean __fieldColumnCount55aSet = false;
1803 
1804     /**
1805      * The number of columns for this field, null if default browser value is desired.
1806      * @return (Integer)handleGetFieldColumnCount()
1807      */
1808     public final Integer getFieldColumnCount()
1809     {
1810         Integer fieldColumnCount55a = this.__fieldColumnCount55a;
1811         if (!this.__fieldColumnCount55aSet)
1812         {
1813             // fieldColumnCount has no pre constraints
1814             fieldColumnCount55a = handleGetFieldColumnCount();
1815             // fieldColumnCount has no post constraints
1816             this.__fieldColumnCount55a = fieldColumnCount55a;
1817             if (isMetafacadePropertyCachingEnabled())
1818             {
1819                 this.__fieldColumnCount55aSet = true;
1820             }
1821         }
1822         return fieldColumnCount55a;
1823     }
1824 
1825    /**
1826     * @see StrutsParameter#isCombobox()
1827     * @return boolean
1828     */
1829     protected abstract boolean handleIsCombobox();
1830 
1831     private boolean __combobox56a;
1832     private boolean __combobox56aSet = false;
1833 
1834     /**
1835      * TODO: Model Documentation for
1836      * StrutsParameter.combobox
1837      * @return (boolean)handleIsCombobox()
1838      */
1839     public final boolean isCombobox()
1840     {
1841         boolean combobox56a = this.__combobox56a;
1842         if (!this.__combobox56aSet)
1843         {
1844             // combobox has no pre constraints
1845             combobox56a = handleIsCombobox();
1846             // combobox has no post constraints
1847             this.__combobox56a = combobox56a;
1848             if (isMetafacadePropertyCachingEnabled())
1849             {
1850                 this.__combobox56aSet = true;
1851             }
1852         }
1853         return combobox56a;
1854     }
1855 
1856    /**
1857     * @see StrutsParameter#isCheckbox()
1858     * @return boolean
1859     */
1860     protected abstract boolean handleIsCheckbox();
1861 
1862     private boolean __checkbox57a;
1863     private boolean __checkbox57aSet = false;
1864 
1865     /**
1866      * TODO: Model Documentation for
1867      * StrutsParameter.checkbox
1868      * @return (boolean)handleIsCheckbox()
1869      */
1870     public final boolean isCheckbox()
1871     {
1872         boolean checkbox57a = this.__checkbox57a;
1873         if (!this.__checkbox57aSet)
1874         {
1875             // checkbox has no pre constraints
1876             checkbox57a = handleIsCheckbox();
1877             // checkbox has no post constraints
1878             this.__checkbox57a = checkbox57a;
1879             if (isMetafacadePropertyCachingEnabled())
1880             {
1881                 this.__checkbox57aSet = true;
1882             }
1883         }
1884         return checkbox57a;
1885     }
1886 
1887    /**
1888     * @see StrutsParameter#isTextField()
1889     * @return boolean
1890     */
1891     protected abstract boolean handleIsTextField();
1892 
1893     private boolean __textField58a;
1894     private boolean __textField58aSet = false;
1895 
1896     /**
1897      * TODO: Model Documentation for
1898      * StrutsParameter.textField
1899      * @return (boolean)handleIsTextField()
1900      */
1901     public final boolean isTextField()
1902     {
1903         boolean textField58a = this.__textField58a;
1904         if (!this.__textField58aSet)
1905         {
1906             // textField has no pre constraints
1907             textField58a = handleIsTextField();
1908             // textField has no post constraints
1909             this.__textField58a = textField58a;
1910             if (isMetafacadePropertyCachingEnabled())
1911             {
1912                 this.__textField58aSet = true;
1913             }
1914         }
1915         return textField58a;
1916     }
1917 
1918    /**
1919     * @see StrutsParameter#isTextArea()
1920     * @return boolean
1921     */
1922     protected abstract boolean handleIsTextArea();
1923 
1924     private boolean __textArea59a;
1925     private boolean __textArea59aSet = false;
1926 
1927     /**
1928      * TODO: Model Documentation for
1929      * StrutsParameter.textArea
1930      * @return (boolean)handleIsTextArea()
1931      */
1932     public final boolean isTextArea()
1933     {
1934         boolean textArea59a = this.__textArea59a;
1935         if (!this.__textArea59aSet)
1936         {
1937             // textArea has no pre constraints
1938             textArea59a = handleIsTextArea();
1939             // textArea has no post constraints
1940             this.__textArea59a = textArea59a;
1941             if (isMetafacadePropertyCachingEnabled())
1942             {
1943                 this.__textArea59aSet = true;
1944             }
1945         }
1946         return textArea59a;
1947     }
1948 
1949    /**
1950     * @see StrutsParameter#isMultibox()
1951     * @return boolean
1952     */
1953     protected abstract boolean handleIsMultibox();
1954 
1955     private boolean __multibox60a;
1956     private boolean __multibox60aSet = false;
1957 
1958     /**
1959      * TODO: Model Documentation for
1960      * StrutsParameter.multibox
1961      * @return (boolean)handleIsMultibox()
1962      */
1963     public final boolean isMultibox()
1964     {
1965         boolean multibox60a = this.__multibox60a;
1966         if (!this.__multibox60aSet)
1967         {
1968             // multibox has no pre constraints
1969             multibox60a = handleIsMultibox();
1970             // multibox has no post constraints
1971             this.__multibox60a = multibox60a;
1972             if (isMetafacadePropertyCachingEnabled())
1973             {
1974                 this.__multibox60aSet = true;
1975             }
1976         }
1977         return multibox60a;
1978     }
1979 
1980    /**
1981     * @see StrutsParameter#isRadioButton()
1982     * @return boolean
1983     */
1984     protected abstract boolean handleIsRadioButton();
1985 
1986     private boolean __radioButton61a;
1987     private boolean __radioButton61aSet = false;
1988 
1989     /**
1990      * TODO: Model Documentation for
1991      * StrutsParameter.radioButton
1992      * @return (boolean)handleIsRadioButton()
1993      */
1994     public final boolean isRadioButton()
1995     {
1996         boolean radioButton61a = this.__radioButton61a;
1997         if (!this.__radioButton61aSet)
1998         {
1999             // radioButton has no pre constraints
2000             radioButton61a = handleIsRadioButton();
2001             // radioButton has no post constraints
2002             this.__radioButton61a = radioButton61a;
2003             if (isMetafacadePropertyCachingEnabled())
2004             {
2005                 this.__radioButton61aSet = true;
2006             }
2007         }
2008         return radioButton61a;
2009     }
2010 
2011    /**
2012     * @see StrutsParameter#isHiddenField()
2013     * @return boolean
2014     */
2015     protected abstract boolean handleIsHiddenField();
2016 
2017     private boolean __hiddenField62a;
2018     private boolean __hiddenField62aSet = false;
2019 
2020     /**
2021      * TODO: Model Documentation for
2022      * StrutsParameter.hiddenField
2023      * @return (boolean)handleIsHiddenField()
2024      */
2025     public final boolean isHiddenField()
2026     {
2027         boolean hiddenField62a = this.__hiddenField62a;
2028         if (!this.__hiddenField62aSet)
2029         {
2030             // hiddenField has no pre constraints
2031             hiddenField62a = handleIsHiddenField();
2032             // hiddenField has no post constraints
2033             this.__hiddenField62a = hiddenField62a;
2034             if (isMetafacadePropertyCachingEnabled())
2035             {
2036                 this.__hiddenField62aSet = true;
2037             }
2038         }
2039         return hiddenField62a;
2040     }
2041 
2042    /**
2043     * @see StrutsParameter#isHyperlink()
2044     * @return boolean
2045     */
2046     protected abstract boolean handleIsHyperlink();
2047 
2048     private boolean __hyperlink63a;
2049     private boolean __hyperlink63aSet = false;
2050 
2051     /**
2052      * TODO: Model Documentation for
2053      * StrutsParameter.hyperlink
2054      * @return (boolean)handleIsHyperlink()
2055      */
2056     public final boolean isHyperlink()
2057     {
2058         boolean hyperlink63a = this.__hyperlink63a;
2059         if (!this.__hyperlink63aSet)
2060         {
2061             // hyperlink has no pre constraints
2062             hyperlink63a = handleIsHyperlink();
2063             // hyperlink has no post constraints
2064             this.__hyperlink63a = hyperlink63a;
2065             if (isMetafacadePropertyCachingEnabled())
2066             {
2067                 this.__hyperlink63aSet = true;
2068             }
2069         }
2070         return hyperlink63a;
2071     }
2072 
2073    /**
2074     * @see StrutsParameter#isSafeNamePresent()
2075     * @return boolean
2076     */
2077     protected abstract boolean handleIsSafeNamePresent();
2078 
2079     private boolean __safeNamePresent64a;
2080     private boolean __safeNamePresent64aSet = false;
2081 
2082     /**
2083      * True if this parameter has a name that can properly be handled by Jakarta commons (this lib
2084      * is used by Struts but contains a bug)
2085      * @return (boolean)handleIsSafeNamePresent()
2086      */
2087     public final boolean isSafeNamePresent()
2088     {
2089         boolean safeNamePresent64a = this.__safeNamePresent64a;
2090         if (!this.__safeNamePresent64aSet)
2091         {
2092             // safeNamePresent has no pre constraints
2093             safeNamePresent64a = handleIsSafeNamePresent();
2094             // safeNamePresent has no post constraints
2095             this.__safeNamePresent64a = safeNamePresent64a;
2096             if (isMetafacadePropertyCachingEnabled())
2097             {
2098                 this.__safeNamePresent64aSet = true;
2099             }
2100         }
2101         return safeNamePresent64a;
2102     }
2103 
2104     // ---------------- business methods ----------------------
2105 
2106     /**
2107      * Method to be implemented in descendants
2108      * Returns the arguments for this parameter's validators.
2109      * @param validatorType
2110      * @return Collection
2111      */
2112     protected abstract Collection handleGetValidatorArgs(String validatorType);
2113 
2114     /**
2115      * Returns the arguments for this parameter's validators.
2116      * @param validatorType String
2117      * TODO: Model Documentation for
2118      * StrutsParameter.getValidatorArgs(validatorType)
2119      * @return handleGetValidatorArgs(validatorType)
2120      */
2121     public Collection getValidatorArgs(String validatorType)
2122     {
2123         // getValidatorArgs has no pre constraints
2124         Collection returnValue = handleGetValidatorArgs(validatorType);
2125         // getValidatorArgs has no post constraints
2126         return returnValue;
2127     }
2128 
2129     /**
2130      * Method to be implemented in descendants
2131      * Returns the resource bundle key for this table's column, only returns a value when this
2132      * parameter is a table.
2133      * @param columnName
2134      * @return String
2135      */
2136     protected abstract String handleGetTableColumnMessageKey(String columnName);
2137 
2138     /**
2139      * Returns the resource bundle key for this table's column, only returns a value when this
2140      * parameter is a table.
2141      * @param columnName String
2142      * TODO: Model Documentation for
2143      * StrutsParameter.getTableColumnMessageKey(columnName)
2144      * @return handleGetTableColumnMessageKey(columnName)
2145      */
2146     public String getTableColumnMessageKey(String columnName)
2147     {
2148         // getTableColumnMessageKey has no pre constraints
2149         String returnValue = handleGetTableColumnMessageKey(columnName);
2150         // getTableColumnMessageKey has no post constraints
2151         return returnValue;
2152     }
2153 
2154     /**
2155      * Method to be implemented in descendants
2156      * Returns the resource bundle value for this table's column, only returns a value when this
2157      * parameter is a table.
2158      * @param columnName
2159      * @return String
2160      */
2161     protected abstract String handleGetTableColumnMessageValue(String columnName);
2162 
2163     /**
2164      * Returns the resource bundle value for this table's column, only returns a value when this
2165      * parameter is a table.
2166      * @param columnName String
2167      * TODO: Model Documentation for
2168      * StrutsParameter.getTableColumnMessageValue(columnName)
2169      * @return handleGetTableColumnMessageValue(columnName)
2170      */
2171     public String getTableColumnMessageValue(String columnName)
2172     {
2173         // getTableColumnMessageValue has no pre constraints
2174         String returnValue = handleGetTableColumnMessageValue(columnName);
2175         // getTableColumnMessageValue has no post constraints
2176         return returnValue;
2177     }
2178 
2179     /**
2180      * Method to be implemented in descendants
2181      * Those actions that are targetting this table's columns, only makes sense when this parameter
2182      * represents a table page-variable.
2183      * @param columnName
2184      * @return List
2185      */
2186     protected abstract List handleGetTableColumnActions(String columnName);
2187 
2188     /**
2189      * Those actions that are targetting this table's columns, only makes sense when this parameter
2190      * represents a table page-variable.
2191      * @param columnName String
2192      * TODO: Model Documentation for
2193      * StrutsParameter.getTableColumnActions(columnName)
2194      * @return handleGetTableColumnActions(columnName)
2195      */
2196     public List getTableColumnActions(String columnName)
2197     {
2198         // getTableColumnActions has no pre constraints
2199         List returnValue = handleGetTableColumnActions(columnName);
2200         // getTableColumnActions has no post constraints
2201         return returnValue;
2202     }
2203 
2204     // ------------- associations ------------------
2205 
2206     private List<StrutsAction> __getTableHyperlinkActions1r;
2207     private boolean __getTableHyperlinkActions1rSet = false;
2208 
2209     /**
2210      * If the action is a table link then this property represents the table to which is being
2211      * linked.
2212      * @return (List<StrutsAction>)handleGetTableHyperlinkActions()
2213      */
2214     public final List<StrutsAction> getTableHyperlinkActions()
2215     {
2216         List<StrutsAction> getTableHyperlinkActions1r = this.__getTableHyperlinkActions1r;
2217         if (!this.__getTableHyperlinkActions1rSet)
2218         {
2219             // tableLinkParameter has no pre constraints
2220             List result = handleGetTableHyperlinkActions();
2221             List shieldedResult = this.shieldedElements(result);
2222             try
2223             {
2224                 getTableHyperlinkActions1r = (List<StrutsAction>)shieldedResult;
2225             }
2226             catch (ClassCastException ex)
2227             {
2228                 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
2229                 StrutsParameterLogic.logger.warn("incorrect metafacade cast for StrutsParameterLogic.getTableHyperlinkActions List<StrutsAction> " + result + ": " + shieldedResult);
2230             }
2231             // tableLinkParameter has no post constraints
2232             this.__getTableHyperlinkActions1r = getTableHyperlinkActions1r;
2233             if (isMetafacadePropertyCachingEnabled())
2234             {
2235                 this.__getTableHyperlinkActions1rSet = true;
2236             }
2237         }
2238         return getTableHyperlinkActions1r;
2239     }
2240 
2241     /**
2242      * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
2243      * @return  List
2244      */
2245     protected abstract List handleGetTableHyperlinkActions();
2246 
2247     private StrutsAction __getStrutsAction2r;
2248     private boolean __getStrutsAction2rSet = false;
2249 
2250     /**
2251      * A Struts parameter is an object communicated between the client and the server. Typically
2252      * form beans
2253      * encapsulate such parameters.
2254      * @return (StrutsAction)handleGetStrutsAction()
2255      */
2256     public final StrutsAction getStrutsAction()
2257     {
2258         StrutsAction getStrutsAction2r = this.__getStrutsAction2r;
2259         if (!this.__getStrutsAction2rSet)
2260         {
2261             // strutsParameter has no pre constraints
2262             Object result = handleGetStrutsAction();
2263             MetafacadeBase shieldedResult = this.shieldedElement(result);
2264             try
2265             {
2266                 getStrutsAction2r = (StrutsAction)shieldedResult;
2267             }
2268             catch (ClassCastException ex)
2269             {
2270                 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
2271                 StrutsParameterLogic.logger.warn("incorrect metafacade cast for StrutsParameterLogic.getStrutsAction StrutsAction " + result + ": " + shieldedResult);
2272             }
2273             // strutsParameter has no post constraints
2274             this.__getStrutsAction2r = getStrutsAction2r;
2275             if (isMetafacadePropertyCachingEnabled())
2276             {
2277                 this.__getStrutsAction2rSet = true;
2278             }
2279         }
2280         return getStrutsAction2r;
2281     }
2282 
2283     /**
2284      * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
2285      * @return Object
2286      */
2287     protected abstract Object handleGetStrutsAction();
2288 
2289     private StrutsJsp __getJsp3r;
2290     private boolean __getJsp3rSet = false;
2291 
2292     /**
2293      * A Struts parameter is an object communicated between the client and the server. Typically
2294      * form beans
2295      * encapsulate such parameters.
2296      * @return (StrutsJsp)handleGetJsp()
2297      */
2298     public final StrutsJsp getJsp()
2299     {
2300         StrutsJsp getJsp3r = this.__getJsp3r;
2301         if (!this.__getJsp3rSet)
2302         {
2303             // strutsParameter has no pre constraints
2304             Object result = handleGetJsp();
2305             MetafacadeBase shieldedResult = this.shieldedElement(result);
2306             try
2307             {
2308                 getJsp3r = (StrutsJsp)shieldedResult;
2309             }
2310             catch (ClassCastException ex)
2311             {
2312                 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
2313                 StrutsParameterLogic.logger.warn("incorrect metafacade cast for StrutsParameterLogic.getJsp StrutsJsp " + result + ": " + shieldedResult);
2314             }
2315             // strutsParameter has no post constraints
2316             this.__getJsp3r = getJsp3r;
2317             if (isMetafacadePropertyCachingEnabled())
2318             {
2319                 this.__getJsp3rSet = true;
2320             }
2321         }
2322         return getJsp3r;
2323     }
2324 
2325     /**
2326      * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
2327      * @return Object
2328      */
2329     protected abstract Object handleGetJsp();
2330 
2331     private StrutsParameter __getTableGlobalActionParameter4r;
2332     private boolean __getTableGlobalActionParameter4rSet = false;
2333 
2334     /**
2335      * A Struts parameter is an object communicated between the client and the server. Typically
2336      * form beans
2337      * encapsulate such parameters.
2338      * @return (StrutsParameter)handleGetTableGlobalActionParameter()
2339      */
2340     public final StrutsParameter getTableGlobalActionParameter()
2341     {
2342         StrutsParameter getTableGlobalActionParameter4r = this.__getTableGlobalActionParameter4r;
2343         if (!this.__getTableGlobalActionParameter4rSet)
2344         {
2345             // strutsParameter has no pre constraints
2346             Object result = handleGetTableGlobalActionParameter();
2347             MetafacadeBase shieldedResult = this.shieldedElement(result);
2348             try
2349             {
2350                 getTableGlobalActionParameter4r = (StrutsParameter)shieldedResult;
2351             }
2352             catch (ClassCastException ex)
2353             {
2354                 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
2355                 StrutsParameterLogic.logger.warn("incorrect metafacade cast for StrutsParameterLogic.getTableGlobalActionParameter StrutsParameter " + result + ": " + shieldedResult);
2356             }
2357             // strutsParameter has no post constraints
2358             this.__getTableGlobalActionParameter4r = getTableGlobalActionParameter4r;
2359             if (isMetafacadePropertyCachingEnabled())
2360             {
2361                 this.__getTableGlobalActionParameter4rSet = true;
2362             }
2363         }
2364         return getTableGlobalActionParameter4r;
2365     }
2366 
2367     /**
2368      * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
2369      * @return Object
2370      */
2371     protected abstract Object handleGetTableGlobalActionParameter();
2372 
2373     private List<StrutsParameter> __getFormFields5r;
2374     private boolean __getFormFields5rSet = false;
2375 
2376     /**
2377      * A Struts parameter is an object communicated between the client and the server. Typically
2378      * form beans
2379      * encapsulate such parameters.
2380      * @return (List<StrutsParameter>)handleGetFormFields()
2381      */
2382     public final List<StrutsParameter> getFormFields()
2383     {
2384         List<StrutsParameter> getFormFields5r = this.__getFormFields5r;
2385         if (!this.__getFormFields5rSet)
2386         {
2387             // strutsParameter has no pre constraints
2388             List result = handleGetFormFields();
2389             List shieldedResult = this.shieldedElements(result);
2390             try
2391             {
2392                 getFormFields5r = (List<StrutsParameter>)shieldedResult;
2393             }
2394             catch (ClassCastException ex)
2395             {
2396                 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
2397                 StrutsParameterLogic.logger.warn("incorrect metafacade cast for StrutsParameterLogic.getFormFields List<StrutsParameter> " + result + ": " + shieldedResult);
2398             }
2399             // strutsParameter has no post constraints
2400             this.__getFormFields5r = getFormFields5r;
2401             if (isMetafacadePropertyCachingEnabled())
2402             {
2403                 this.__getFormFields5rSet = true;
2404             }
2405         }
2406         return getFormFields5r;
2407     }
2408 
2409     /**
2410      * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
2411      * @return  List
2412      */
2413     protected abstract List handleGetFormFields();
2414 
2415     private Collection<StrutsAction> __getTableGlobalActions6r;
2416     private boolean __getTableGlobalActions6rSet = false;
2417 
2418     /**
2419      * A Struts parameter is an object communicated between the client and the server. Typically
2420      * form beans
2421      * encapsulate such parameters.
2422      * @return (Collection<StrutsAction>)handleGetTableGlobalActions()
2423      */
2424     public final Collection<StrutsAction> getTableGlobalActions()
2425     {
2426         Collection<StrutsAction> getTableGlobalActions6r = this.__getTableGlobalActions6r;
2427         if (!this.__getTableGlobalActions6rSet)
2428         {
2429             // strutsParameter has no pre constraints
2430             Collection result = handleGetTableGlobalActions();
2431             List shieldedResult = this.shieldedElements(result);
2432             try
2433             {
2434                 getTableGlobalActions6r = (Collection<StrutsAction>)shieldedResult;
2435             }
2436             catch (ClassCastException ex)
2437             {
2438                 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
2439                 StrutsParameterLogic.logger.warn("incorrect metafacade cast for StrutsParameterLogic.getTableGlobalActions Collection<StrutsAction> " + result + ": " + shieldedResult);
2440             }
2441             // strutsParameter has no post constraints
2442             this.__getTableGlobalActions6r = getTableGlobalActions6r;
2443             if (isMetafacadePropertyCachingEnabled())
2444             {
2445                 this.__getTableGlobalActions6rSet = true;
2446             }
2447         }
2448         return getTableGlobalActions6r;
2449     }
2450 
2451     /**
2452      * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
2453      * @return  Collection
2454      */
2455     protected abstract Collection handleGetTableGlobalActions();
2456 
2457     private List<StrutsAction> __getTableFormActions7r;
2458     private boolean __getTableFormActions7rSet = false;
2459 
2460     /**
2461      * Returns all parameters transported in this action.
2462      * @return (List<StrutsAction>)handleGetTableFormActions()
2463      */
2464     public final List<StrutsAction> getTableFormActions()
2465     {
2466         List<StrutsAction> getTableFormActions7r = this.__getTableFormActions7r;
2467         if (!this.__getTableFormActions7rSet)
2468         {
2469             // actionParameters has no pre constraints
2470             List result = handleGetTableFormActions();
2471             List shieldedResult = this.shieldedElements(result);
2472             try
2473             {
2474                 getTableFormActions7r = (List<StrutsAction>)shieldedResult;
2475             }
2476             catch (ClassCastException ex)
2477             {
2478                 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
2479                 StrutsParameterLogic.logger.warn("incorrect metafacade cast for StrutsParameterLogic.getTableFormActions List<StrutsAction> " + result + ": " + shieldedResult);
2480             }
2481             // actionParameters has no post constraints
2482             this.__getTableFormActions7r = getTableFormActions7r;
2483             if (isMetafacadePropertyCachingEnabled())
2484             {
2485                 this.__getTableFormActions7rSet = true;
2486             }
2487         }
2488         return getTableFormActions7r;
2489     }
2490 
2491     /**
2492      * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
2493      * @return  List
2494      */
2495     protected abstract List handleGetTableFormActions();
2496 
2497     /**
2498      * @return true
2499      * @see FrontEndParameter
2500      */
2501     public boolean isFrontEndParameterMetaType()
2502     {
2503         return true;
2504     }
2505 
2506     /**
2507      * @return true
2508      * @see org.andromda.metafacades.uml.ParameterFacade
2509      */
2510     public boolean isParameterFacadeMetaType()
2511     {
2512         return true;
2513     }
2514 
2515     /**
2516      * @return true
2517      * @see ModelElementFacade
2518      */
2519     public boolean isModelElementFacadeMetaType()
2520     {
2521         return true;
2522     }
2523 
2524     // ----------- delegates to FrontEndParameter ------------
2525     /**
2526      * The action to which this parameter belongs (if it belongs to an action), otherwise it returns
2527      * null.
2528      * @see FrontEndParameter#getAction()
2529      */
2530     public FrontEndAction getAction()
2531     {
2532         return this.getSuperFrontEndParameter().getAction();
2533     }
2534 
2535     /**
2536      * Gets the controller operation to which this parameter belongs.
2537      * @see FrontEndParameter#getControllerOperation()
2538      */
2539     public FrontEndControllerOperation getControllerOperation()
2540     {
2541         return this.getSuperFrontEndParameter().getControllerOperation();
2542     }
2543 
2544     /**
2545      * A collection of all possible attribute names of a table (this will only work when your table
2546      * is modeled as an array..not a collection).
2547      * @see FrontEndParameter#getTableAttributeNames()
2548      */
2549     public Collection<String> getTableAttributeNames()
2550     {
2551         return this.getSuperFrontEndParameter().getTableAttributeNames();
2552     }
2553 
2554     /**
2555      * All the columns for this parameter if it represents a table variable. If a column is linked
2556      * by an event (action) a FrontEndParameter instance is included in the return value, otherwise
2557      * a plain String representing the column name.
2558      * @see FrontEndParameter#getTableColumnNames()
2559      */
2560     public Collection<String> getTableColumnNames()
2561     {
2562         return this.getSuperFrontEndParameter().getTableColumnNames();
2563     }
2564 
2565     /**
2566      * A list of all attributes which make up the table columns of this table (this only contains
2567      * attributes when the table is represented by an array).
2568      * @see FrontEndParameter#getTableColumns()
2569      */
2570     public Collection<String> getTableColumns()
2571     {
2572         return this.getSuperFrontEndParameter().getTableColumns();
2573     }
2574 
2575     /**
2576      * Represents the view in which this parameter will be used.
2577      * @see FrontEndParameter#getView()
2578      */
2579     public FrontEndView getView()
2580     {
2581         return this.getSuperFrontEndParameter().getView();
2582     }
2583 
2584     /**
2585      * Indicates whether or not this is an action parameter or not.
2586      * @see FrontEndParameter#isActionParameter()
2587      */
2588     public boolean isActionParameter()
2589     {
2590         return this.getSuperFrontEndParameter().isActionParameter();
2591     }
2592 
2593     /**
2594      * Indicates if this parameter is contained in a "front-end" use case.
2595      * @see FrontEndParameter#isContainedInFrontEndUseCase()
2596      */
2597     public boolean isContainedInFrontEndUseCase()
2598     {
2599         return this.getSuperFrontEndParameter().isContainedInFrontEndUseCase();
2600     }
2601 
2602     /**
2603      * Indicates whether or not this parameter is an argument of a controller operation.
2604      * @see FrontEndParameter#isControllerOperationArgument()
2605      */
2606     public boolean isControllerOperationArgument()
2607     {
2608         return this.getSuperFrontEndParameter().isControllerOperationArgument();
2609     }
2610 
2611     /**
2612      * Indicates whether or not this parameter represents a table.
2613      * @see FrontEndParameter#isTable()
2614      */
2615     public boolean isTable()
2616     {
2617         return this.getSuperFrontEndParameter().isTable();
2618     }
2619 
2620     /**
2621      * Copies all tagged values from the given ModelElementFacade to this model element facade.
2622      * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element)
2623      */
2624     public void copyTaggedValues(ModelElementFacade element)
2625     {
2626         this.getSuperFrontEndParameter().copyTaggedValues(element);
2627     }
2628 
2629     /**
2630      * Finds the tagged value with the specified 'tagName'. In case there are more values the first
2631      * one found will be returned.
2632      * @see ModelElementFacade#findTaggedValue(String tagName)
2633      */
2634     public Object findTaggedValue(String tagName)
2635     {
2636         return this.getSuperFrontEndParameter().findTaggedValue(tagName);
2637     }
2638 
2639     /**
2640      * Returns all the values for the tagged value with the specified name. The returned collection
2641      * will contains only String instances, or will be empty. Never null.
2642      * @see ModelElementFacade#findTaggedValues(String tagName)
2643      */
2644     public Collection<Object> findTaggedValues(String tagName)
2645     {
2646         return this.getSuperFrontEndParameter().findTaggedValues(tagName);
2647     }
2648 
2649     /**
2650      * Returns the fully qualified name of the model element. The fully qualified name includes
2651      * complete package qualified name of the underlying model element. The templates parameter will
2652      * be replaced by the correct one given the binding relation of the parameter to this element.
2653      * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement)
2654      */
2655     public String getBindedFullyQualifiedName(ModelElementFacade bindedElement)
2656     {
2657         return this.getSuperFrontEndParameter().getBindedFullyQualifiedName(bindedElement);
2658     }
2659 
2660     /**
2661      * Gets all constraints belonging to the model element.
2662      * @see ModelElementFacade#getConstraints()
2663      */
2664     public Collection<ConstraintFacade> getConstraints()
2665     {
2666         return this.getSuperFrontEndParameter().getConstraints();
2667     }
2668 
2669     /**
2670      * Returns the constraints of the argument kind that have been placed onto this model. Typical
2671      * kinds are "inv", "pre" and "post". Other kinds are possible.
2672      * @see ModelElementFacade#getConstraints(String kind)
2673      */
2674     public Collection<ConstraintFacade> getConstraints(String kind)
2675     {
2676         return this.getSuperFrontEndParameter().getConstraints(kind);
2677     }
2678 
2679     /**
2680      * Gets the documentation for the model element, The indent argument is prefixed to each line.
2681      * By default this method wraps lines after 64 characters.
2682      * This method is equivalent to <code>getDocumentation(indent, 64)</code>.
2683      * @see ModelElementFacade#getDocumentation(String indent)
2684      */
2685     public String getDocumentation(String indent)
2686     {
2687         return this.getSuperFrontEndParameter().getDocumentation(indent);
2688     }
2689 
2690     /**
2691      * This method returns the documentation for this model element, with the lines wrapped after
2692      * the specified number of characters, values of less than 1 will indicate no line wrapping is
2693      * required. By default paragraphs are returned as HTML.
2694      * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>.
2695      * @see ModelElementFacade#getDocumentation(String indent, int lineLength)
2696      */
2697     public String getDocumentation(String indent, int lineLength)
2698     {
2699         return this.getSuperFrontEndParameter().getDocumentation(indent, lineLength);
2700     }
2701 
2702     /**
2703      * This method returns the documentation for this model element, with the lines wrapped after
2704      * the specified number of characters, values of less than 1 will indicate no line wrapping is
2705      * required. HTML style determines if HTML Escaping is applied.
2706      * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle)
2707      */
2708     public String getDocumentation(String indent, int lineLength, boolean htmlStyle)
2709     {
2710         return this.getSuperFrontEndParameter().getDocumentation(indent, lineLength, htmlStyle);
2711     }
2712 
2713     /**
2714      * The fully qualified name of this model element.
2715      * @see ModelElementFacade#getFullyQualifiedName()
2716      */
2717     public String getFullyQualifiedName()
2718     {
2719         return this.getSuperFrontEndParameter().getFullyQualifiedName();
2720     }
2721 
2722     /**
2723      * Returns the fully qualified name of the model element. The fully qualified name includes
2724      * complete package qualified name of the underlying model element.  If modelName is true, then
2725      * the original name of the model element (the name contained within the model) will be the name
2726      * returned, otherwise a name from a language mapping will be returned.
2727      * @see ModelElementFacade#getFullyQualifiedName(boolean modelName)
2728      */
2729     public String getFullyQualifiedName(boolean modelName)
2730     {
2731         return this.getSuperFrontEndParameter().getFullyQualifiedName(modelName);
2732     }
2733 
2734     /**
2735      * Returns the fully qualified name as a path, the returned value always starts with out a slash
2736      * '/'.
2737      * @see ModelElementFacade#getFullyQualifiedNamePath()
2738      */
2739     public String getFullyQualifiedNamePath()
2740     {
2741         return this.getSuperFrontEndParameter().getFullyQualifiedNamePath();
2742     }
2743 
2744     /**
2745      * Gets the unique identifier of the underlying model element.
2746      * @see ModelElementFacade#getId()
2747      */
2748     public String getId()
2749     {
2750         return this.getSuperFrontEndParameter().getId();
2751     }
2752 
2753     /**
2754      * UML2: Retrieves the keywords for this element. Used to modify implementation properties which
2755      * are not represented by other properties, i.e. native, transient, volatile, synchronized,
2756      * (added annotations) override, deprecated. Can also be used to suppress compiler warnings:
2757      * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require
2758      * JDK5 compiler level.
2759      * @see ModelElementFacade#getKeywords()
2760      */
2761     public Collection<String> getKeywords()
2762     {
2763         return this.getSuperFrontEndParameter().getKeywords();
2764     }
2765 
2766     /**
2767      * UML2: Retrieves a localized label for this named element.
2768      * @see ModelElementFacade#getLabel()
2769      */
2770     public String getLabel()
2771     {
2772         return this.getSuperFrontEndParameter().getLabel();
2773     }
2774 
2775     /**
2776      * The language mappings that have been set for this model element.
2777      * @see ModelElementFacade#getLanguageMappings()
2778      */
2779     public TypeMappings getLanguageMappings()
2780     {
2781         return this.getSuperFrontEndParameter().getLanguageMappings();
2782     }
2783 
2784     /**
2785      * Return the model containing this model element (multiple models may be loaded and processed
2786      * at the same time).
2787      * @see ModelElementFacade#getModel()
2788      */
2789     public ModelFacade getModel()
2790     {
2791         return this.getSuperFrontEndParameter().getModel();
2792     }
2793 
2794     /**
2795      * The name of the model element.
2796      * @see ModelElementFacade#getName()
2797      */
2798     public String getName()
2799     {
2800         return this.getSuperFrontEndParameter().getName();
2801     }
2802 
2803     /**
2804      * Gets the package to which this model element belongs.
2805      * @see ModelElementFacade#getPackage()
2806      */
2807     public ModelElementFacade getPackage()
2808     {
2809         return this.getSuperFrontEndParameter().getPackage();
2810     }
2811 
2812     /**
2813      * The name of this model element's package.
2814      * @see ModelElementFacade#getPackageName()
2815      */
2816     public String getPackageName()
2817     {
2818         return this.getSuperFrontEndParameter().getPackageName();
2819     }
2820 
2821     /**
2822      * Gets the package name (optionally providing the ability to retrieve the model name and not
2823      * the mapped name).
2824      * @see ModelElementFacade#getPackageName(boolean modelName)
2825      */
2826     public String getPackageName(boolean modelName)
2827     {
2828         return this.getSuperFrontEndParameter().getPackageName(modelName);
2829     }
2830 
2831     /**
2832      * Returns the package as a path, the returned value always starts with out a slash '/'.
2833      * @see ModelElementFacade#getPackagePath()
2834      */
2835     public String getPackagePath()
2836     {
2837         return this.getSuperFrontEndParameter().getPackagePath();
2838     }
2839 
2840     /**
2841      * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the
2842      * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from
2843      * the names of the containing namespaces starting at the root of the hierarchy and ending with
2844      * the name of the NamedElement itself.
2845      * @see ModelElementFacade#getQualifiedName()
2846      */
2847     public String getQualifiedName()
2848     {
2849         return this.getSuperFrontEndParameter().getQualifiedName();
2850     }
2851 
2852     /**
2853      * Gets the root package for the model element.
2854      * @see ModelElementFacade#getRootPackage()
2855      */
2856     public PackageFacade getRootPackage()
2857     {
2858         return this.getSuperFrontEndParameter().getRootPackage();
2859     }
2860 
2861     /**
2862      * Gets the dependencies for which this model element is the source.
2863      * @see ModelElementFacade#getSourceDependencies()
2864      */
2865     public Collection<DependencyFacade> getSourceDependencies()
2866     {
2867         return this.getSuperFrontEndParameter().getSourceDependencies();
2868     }
2869 
2870     /**
2871      * If this model element is the context of an activity graph, this represents that activity
2872      * graph.
2873      * @see ModelElementFacade#getStateMachineContext()
2874      */
2875     public StateMachineFacade getStateMachineContext()
2876     {
2877         return this.getSuperFrontEndParameter().getStateMachineContext();
2878     }
2879 
2880     /**
2881      * The collection of ALL stereotype names for this model element.
2882      * @see ModelElementFacade#getStereotypeNames()
2883      */
2884     public Collection<String> getStereotypeNames()
2885     {
2886         return this.getSuperFrontEndParameter().getStereotypeNames();
2887     }
2888 
2889     /**
2890      * Gets all stereotypes for this model element.
2891      * @see ModelElementFacade#getStereotypes()
2892      */
2893     public Collection<StereotypeFacade> getStereotypes()
2894     {
2895         return this.getSuperFrontEndParameter().getStereotypes();
2896     }
2897 
2898     /**
2899      * Return the TaggedValues associated with this model element, under all stereotypes.
2900      * @see ModelElementFacade#getTaggedValues()
2901      */
2902     public Collection<TaggedValueFacade> getTaggedValues()
2903     {
2904         return this.getSuperFrontEndParameter().getTaggedValues();
2905     }
2906 
2907     /**
2908      * Gets the dependencies for which this model element is the target.
2909      * @see ModelElementFacade#getTargetDependencies()
2910      */
2911     public Collection<DependencyFacade> getTargetDependencies()
2912     {
2913         return this.getSuperFrontEndParameter().getTargetDependencies();
2914     }
2915 
2916     /**
2917      * Get the template parameter for this model element having the parameterName
2918      * @see ModelElementFacade#getTemplateParameter(String parameterName)
2919      */
2920     public Object getTemplateParameter(String parameterName)
2921     {
2922         return this.getSuperFrontEndParameter().getTemplateParameter(parameterName);
2923     }
2924 
2925     /**
2926      * Get the template parameters for this model element
2927      * @see ModelElementFacade#getTemplateParameters()
2928      */
2929     public Collection<TemplateParameterFacade> getTemplateParameters()
2930     {
2931         return this.getSuperFrontEndParameter().getTemplateParameters();
2932     }
2933 
2934     /**
2935      * The visibility (i.e. public, private, protected or package) of the model element, will
2936      * attempt a lookup for these values in the language mappings (if any).
2937      * @see ModelElementFacade#getVisibility()
2938      */
2939     public String getVisibility()
2940     {
2941         return this.getSuperFrontEndParameter().getVisibility();
2942     }
2943 
2944     /**
2945      * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance
2946      * is taken into account when searching for the stereotype), false otherwise.
2947      * @see ModelElementFacade#hasExactStereotype(String stereotypeName)
2948      */
2949     public boolean hasExactStereotype(String stereotypeName)
2950     {
2951         return this.getSuperFrontEndParameter().hasExactStereotype(stereotypeName);
2952     }
2953 
2954     /**
2955      * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma,
2956      * pipe, semicolon, or << >>
2957      * @see ModelElementFacade#hasKeyword(String keywordName)
2958      */
2959     public boolean hasKeyword(String keywordName)
2960     {
2961         return this.getSuperFrontEndParameter().hasKeyword(keywordName);
2962     }
2963 
2964     /**
2965      * Returns true if the model element has the specified stereotype.  If the stereotype itself
2966      * does not match, then a search will be made up the stereotype inheritance hierarchy, and if
2967      * one of the stereotype's ancestors has a matching name this method will return true, false
2968      * otherwise.
2969      * For example, if we have a certain stereotype called <<exception>> and a model element has a
2970      * stereotype called <<applicationException>> which extends <<exception>>, when calling this
2971      * method with 'stereotypeName' defined as 'exception' the method would return true since
2972      * <<applicationException>> inherits from <<exception>>.  If you want to check if the model
2973      * element has the exact stereotype, then use the method 'hasExactStereotype' instead.
2974      * @see ModelElementFacade#hasStereotype(String stereotypeName)
2975      */
2976     public boolean hasStereotype(String stereotypeName)
2977     {
2978         return this.getSuperFrontEndParameter().hasStereotype(stereotypeName);
2979     }
2980 
2981     /**
2982      * True if there are target dependencies from this element that are instances of BindingFacade.
2983      * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies.
2984      * @see ModelElementFacade#isBindingDependenciesPresent()
2985      */
2986     public boolean isBindingDependenciesPresent()
2987     {
2988         return this.getSuperFrontEndParameter().isBindingDependenciesPresent();
2989     }
2990 
2991     /**
2992      * Indicates if any constraints are present on this model element.
2993      * @see ModelElementFacade#isConstraintsPresent()
2994      */
2995     public boolean isConstraintsPresent()
2996     {
2997         return this.getSuperFrontEndParameter().isConstraintsPresent();
2998     }
2999 
3000     /**
3001      * Indicates if any documentation is present on this model element.
3002      * @see ModelElementFacade#isDocumentationPresent()
3003      */
3004     public boolean isDocumentationPresent()
3005     {
3006         return this.getSuperFrontEndParameter().isDocumentationPresent();
3007     }
3008 
3009     /**
3010      * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript.
3011      * @see ModelElementFacade#isReservedWord()
3012      */
3013     public boolean isReservedWord()
3014     {
3015         return this.getSuperFrontEndParameter().isReservedWord();
3016     }
3017 
3018     /**
3019      * True is there are template parameters on this model element. For UML2, applies to Class,
3020      * Operation, Property, and Parameter.
3021      * @see ModelElementFacade#isTemplateParametersPresent()
3022      */
3023     public boolean isTemplateParametersPresent()
3024     {
3025         return this.getSuperFrontEndParameter().isTemplateParametersPresent();
3026     }
3027 
3028     /**
3029      * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++,
3030      * JavaScript. Contains no spaces, special characters etc. Constraint always applied on
3031      * Enumerations and Interfaces, optionally applies on other model elements.
3032      * @see ModelElementFacade#isValidIdentifierName()
3033      */
3034     public boolean isValidIdentifierName()
3035     {
3036         return this.getSuperFrontEndParameter().isValidIdentifierName();
3037     }
3038 
3039     /**
3040      * Searches for the constraint with the specified 'name' on this model element, and if found
3041      * translates it using the specified 'translation' from a translation library discovered by the
3042      * framework.
3043      * @see ModelElementFacade#translateConstraint(String name, String translation)
3044      */
3045     public String translateConstraint(String name, String translation)
3046     {
3047         return this.getSuperFrontEndParameter().translateConstraint(name, translation);
3048     }
3049 
3050     /**
3051      * Translates all constraints belonging to this model element with the given 'translation'.
3052      * @see ModelElementFacade#translateConstraints(String translation)
3053      */
3054     public String[] translateConstraints(String translation)
3055     {
3056         return this.getSuperFrontEndParameter().translateConstraints(translation);
3057     }
3058 
3059     /**
3060      * Translates the constraints of the specified 'kind' belonging to this model element.
3061      * @see ModelElementFacade#translateConstraints(String kind, String translation)
3062      */
3063     public String[] translateConstraints(String kind, String translation)
3064     {
3065         return this.getSuperFrontEndParameter().translateConstraints(kind, translation);
3066     }
3067 
3068     /**
3069      * TODO: Model Documentation for org.andromda.metafacades.uml.ParameterFacade.defaultValue
3070      * @see org.andromda.metafacades.uml.ParameterFacade#getDefaultValue()
3071      */
3072     public String getDefaultValue()
3073     {
3074         return this.getSuperFrontEndParameter().getDefaultValue();
3075     }
3076 
3077     /**
3078      * UML2: A representation of the literals of the enumeration 'Parameter Effect Kind': CREATE,
3079      * READ, UPDATE, DELETE. The datatype ParameterEffectKind is an enumeration that indicates the
3080      * effect of a behavior on values passed in or out of its parameters.
3081      * @see org.andromda.metafacades.uml.ParameterFacade#getEffect()
3082      */
3083     public String getEffect()
3084     {
3085         return this.getSuperFrontEndParameter().getEffect();
3086     }
3087 
3088     /**
3089      * If this parameter is located on an event, this will represent that event.
3090      * @see org.andromda.metafacades.uml.ParameterFacade#getEvent()
3091      */
3092     public EventFacade getEvent()
3093     {
3094         return this.getSuperFrontEndParameter().getEvent();
3095     }
3096 
3097     /**
3098      * The name to use for accessors getting this parameter from a bean.
3099      * @see org.andromda.metafacades.uml.ParameterFacade#getGetterName()
3100      */
3101     public String getGetterName()
3102     {
3103         return this.getSuperFrontEndParameter().getGetterName();
3104     }
3105 
3106     /**
3107      * Fully Qualified TypeName, determined in part by multiplicity (for UML2). For UML14, same as
3108      * getterName.
3109      * @see org.andromda.metafacades.uml.ParameterFacade#getGetterSetterTypeName()
3110      */
3111     public String getGetterSetterTypeName()
3112     {
3113         return this.getSuperFrontEndParameter().getGetterSetterTypeName();
3114     }
3115 
3116     /**
3117      * Fully Qualified implementation class of TypeName, determined in part by multiplicity (for
3118      * UML2). If upper multiplicity =1, same as getterSetterTypeName.
3119      * @see org.andromda.metafacades.uml.ParameterFacade#getGetterSetterTypeNameImpl()
3120      */
3121     public String getGetterSetterTypeNameImpl()
3122     {
3123         return this.getSuperFrontEndParameter().getGetterSetterTypeNameImpl();
3124     }
3125 
3126     /**
3127      * the lower value for the multiplicity
3128      * -only applicable for UML2
3129      * @see org.andromda.metafacades.uml.ParameterFacade#getLower()
3130      */
3131     public int getLower()
3132     {
3133         return this.getSuperFrontEndParameter().getLower();
3134     }
3135 
3136     /**
3137      * If this parameter is located on an operation, this will represent that operation.
3138      * @see org.andromda.metafacades.uml.ParameterFacade#getOperation()
3139      */
3140     public OperationFacade getOperation()
3141     {
3142         return this.getSuperFrontEndParameter().getOperation();
3143     }
3144 
3145     /**
3146      * The name to use for accessors getting this parameter in a bean.
3147      * @see org.andromda.metafacades.uml.ParameterFacade#getSetterName()
3148      */
3149     public String getSetterName()
3150     {
3151         return this.getSuperFrontEndParameter().getSetterName();
3152     }
3153 
3154     /**
3155      * A Classifier is a classification of instances - it describes a set of instances that have
3156      * features
3157      * in common. Can specify a generalization hierarchy by referencing its general classifiers. It
3158      * may be
3159      * a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
3160      * generalization hierarchy by referencing its general classifiers. Has the capability to own
3161      * collaboration uses. These collaboration uses link a collaboration with the classifier to give
3162      * a
3163      * description of the workings of the classifier. Classifier is defined to be a kind of
3164      * templateable
3165      * element so that a classifier can be parameterized. It is also defined to be a kind of
3166      * parameterable
3167      * element so that a classifier can be a formal template parameter.
3168      * @see org.andromda.metafacades.uml.ParameterFacade#getType()
3169      */
3170     public ClassifierFacade getType()
3171     {
3172         return this.getSuperFrontEndParameter().getType();
3173     }
3174 
3175     /**
3176      * the upper value of the multiplicity (will be -1 for *)
3177      * -only applicable for UML2
3178      * @see org.andromda.metafacades.uml.ParameterFacade#getUpper()
3179      */
3180     public int getUpper()
3181     {
3182         return this.getSuperFrontEndParameter().getUpper();
3183     }
3184 
3185     /**
3186      * Indicates if the default value is present.
3187      * @see org.andromda.metafacades.uml.ParameterFacade#isDefaultValuePresent()
3188      */
3189     public boolean isDefaultValuePresent()
3190     {
3191         return this.getSuperFrontEndParameter().isDefaultValuePresent();
3192     }
3193 
3194     /**
3195      * UML2: Returns the value of the 'Is Exception' attribute. The default value is "false". Tells
3196      * whether an output parameter may emit a value to the exclusion of the other outputs.
3197      * @see org.andromda.metafacades.uml.ParameterFacade#isException()
3198      */
3199     public boolean isException()
3200     {
3201         return this.getSuperFrontEndParameter().isException();
3202     }
3203 
3204     /**
3205      * True if this parameter is an 'in' parameter.
3206      * @see org.andromda.metafacades.uml.ParameterFacade#isInParameter()
3207      */
3208     public boolean isInParameter()
3209     {
3210         return this.getSuperFrontEndParameter().isInParameter();
3211     }
3212 
3213     /**
3214      * True if this parameter is an inout parameter.
3215      * @see org.andromda.metafacades.uml.ParameterFacade#isInoutParameter()
3216      */
3217     public boolean isInoutParameter()
3218     {
3219         return this.getSuperFrontEndParameter().isInoutParameter();
3220     }
3221 
3222     /**
3223      * If upper>1 or upper==unlimited. Only applies to UML2. For UML14, always false.
3224      * @see org.andromda.metafacades.uml.ParameterFacade#isMany()
3225      */
3226     public boolean isMany()
3227     {
3228         return this.getSuperFrontEndParameter().isMany();
3229     }
3230 
3231     /**
3232      * UML2 Only: Is parameter ordered within the Collection type. Ordered+Unique determines the
3233      * implementation Collection Type. For UML14, always false.
3234      * @see org.andromda.metafacades.uml.ParameterFacade#isOrdered()
3235      */
3236     public boolean isOrdered()
3237     {
3238         return this.getSuperFrontEndParameter().isOrdered();
3239     }
3240 
3241     /**
3242      * True if this parameter is an 'out' parameter.
3243      * @see org.andromda.metafacades.uml.ParameterFacade#isOutParameter()
3244      */
3245     public boolean isOutParameter()
3246     {
3247         return this.getSuperFrontEndParameter().isOutParameter();
3248     }
3249 
3250     /**
3251      * True if this parameter is readable, aka an in-parameter, or this feature is unspecified.
3252      * @see org.andromda.metafacades.uml.ParameterFacade#isReadable()
3253      */
3254     public boolean isReadable()
3255     {
3256         return this.getSuperFrontEndParameter().isReadable();
3257     }
3258 
3259     /**
3260      * Whether or not this parameter is considered required (i.e must a non-empty value).
3261      * @see org.andromda.metafacades.uml.ParameterFacade#isRequired()
3262      */
3263     public boolean isRequired()
3264     {
3265         return this.getSuperFrontEndParameter().isRequired();
3266     }
3267 
3268     /**
3269      * Whether or not this parameter represents a return parameter.
3270      * @see org.andromda.metafacades.uml.ParameterFacade#isReturn()
3271      */
3272     public boolean isReturn()
3273     {
3274         return this.getSuperFrontEndParameter().isReturn();
3275     }
3276 
3277     /**
3278      * If Parameter type isMany (UML2), is the parameter unique within the Collection. Unique+Sorted
3279      * determines pareter implementation type. For UML14, always false.
3280      * @see org.andromda.metafacades.uml.ParameterFacade#isUnique()
3281      */
3282     public boolean isUnique()
3283     {
3284         return this.getSuperFrontEndParameter().isUnique();
3285     }
3286 
3287     /**
3288      * True if this parameter is writable, aka an out-parameter, or this feature is unspecified.
3289      * @see org.andromda.metafacades.uml.ParameterFacade#isWritable()
3290      */
3291     public boolean isWritable()
3292     {
3293         return this.getSuperFrontEndParameter().isWritable();
3294     }
3295 
3296     /**
3297      * @see MetafacadeBase#initialize()
3298      */
3299     @Override
3300     public void initialize()
3301     {
3302         this.getSuperFrontEndParameter().initialize();
3303     }
3304 
3305     /**
3306      * @return Object getSuperFrontEndParameter().getValidationOwner()
3307      * @see MetafacadeBase#getValidationOwner()
3308      */
3309     @Override
3310     public Object getValidationOwner()
3311     {
3312         Object owner = this.getSuperFrontEndParameter().getValidationOwner();
3313         return owner;
3314     }
3315 
3316     /**
3317      * @return String getSuperFrontEndParameter().getValidationName()
3318      * @see MetafacadeBase#getValidationName()
3319      */
3320     @Override
3321     public String getValidationName()
3322     {
3323         String name = this.getSuperFrontEndParameter().getValidationName();
3324         return name;
3325     }
3326 
3327     /**
3328      * <p><b>Constraint:</b> org::andromda::cartridges::bpm4struts::metafacades::StrutsParameter::table on collection or array</p>
3329      * <p><b>Error:</b> A parameter can only be rendered in tabular format when it is a collection or an array.</p>
3330      * <p><b>OCL:</b> context StrutsParameter inv: table implies multiple</p>
3331      * <p><b>Constraint:</b> org::andromda::cartridges::bpm4struts::metafacades::StrutsParameter::table actions must all have one parameter</p>
3332      * <p><b>Error:</b> All actions targetting this table and operating on all visible rows at the same time can only have a single parameter, this parameter denotes the value that will be sent when the row has been selected.</p>
3333      * <p><b>OCL:</b> context StrutsParameter inv: tableGlobalActions->notEmpty() implies tableGlobalActions->forAll(actionParameters->size() = 1)</p>
3334      * <p><b>Constraint:</b> org::andromda::cartridges::bpm4struts::metafacades::StrutsParameter::all global table action must have the same parameter</p>
3335      * <p><b>Error:</b> All actions targetting this table and operating on the entire rowset must have the same event parameter declaration, this means both name and type must match for all parameters in these actions.</p>
3336      * <p><b>OCL:</b> context StrutsParameter inv: tableGlobalActions->notEmpty() implies allGlobalTableActionsHaveSameParameter</p>
3337      * <p><b>Constraint:</b> org::andromda::cartridges::bpm4struts::metafacades::StrutsManageableEntityAttribute::SAFE NAME - TO BE REMOVED LATER</p>
3338      * <p><b>Error:</b> The names you give to fields cannot start with a lowercase character directly followed by a character in uppercase. This is due to a bug in the Jakarta commons library which is used by Struts. The behavior of that library is inconsistent with the reflection API provided by the JDK. Please rename this field or you'll get exceptions when running your web application.</p>
3339      * <p><b>OCL:</b> context StrutsAttribute inv: safeNamePresent</p>
3340      * @param validationMessages Collection<ModelValidationMessage>
3341      * @see MetafacadeBase#validateInvariants(Collection validationMessages)
3342      */
3343     @Override
3344     public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
3345     {
3346         this.getSuperFrontEndParameter().validateInvariants(validationMessages);
3347         try
3348         {
3349             final Object contextElement = this.THIS();
3350             boolean constraintValid = OCLResultEnsurer.ensure((Boolean.valueOf(String.valueOf(Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"table"))).booleanValue())).booleanValue()?Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"multiple"))).booleanValue():true));
3351             if (!constraintValid)
3352             {
3353                 validationMessages.add(
3354                     new ModelValidationMessage(
3355                         (MetafacadeBase)contextElement ,
3356                         "org::andromda::cartridges::bpm4struts::metafacades::StrutsParameter::table on collection or array",
3357                         "A parameter can only be rendered in tabular format when it is a collection or an array."));
3358             }
3359         }
3360         catch (Throwable th)
3361         {
3362             Throwable cause = th.getCause();
3363             int depth = 0; // Some throwables have infinite recursion
3364             while (cause != null && depth < 7)
3365             {
3366                 th = cause;
3367                 depth++;
3368             }
3369             logger.error("Error validating constraint 'org::andromda::cartridges::bpm4struts::metafacades::StrutsParameter::table on collection or array' ON "
3370                 + this.THIS().toString() + ": " + th.getMessage(), th);
3371         }
3372         try
3373         {
3374             final Object contextElement = this.THIS();
3375             boolean constraintValid = OCLResultEnsurer.ensure((Boolean.valueOf(String.valueOf(OCLCollections.notEmpty(OCLIntrospector.invoke(contextElement,"tableGlobalActions")))).booleanValue()?OCLCollections.forAll(OCLIntrospector.invoke(contextElement,"tableGlobalActions"),new Predicate(){public boolean evaluate(Object object){return Boolean.valueOf(String.valueOf(OCLExpressions.equal(OCLCollections.size(OCLIntrospector.invoke(object,"actionParameters")),1))).booleanValue();}}):true));
3376             if (!constraintValid)
3377             {
3378                 validationMessages.add(
3379                     new ModelValidationMessage(
3380                         (MetafacadeBase)contextElement ,
3381                         "org::andromda::cartridges::bpm4struts::metafacades::StrutsParameter::table actions must all have one parameter",
3382                         "All actions targetting this table and operating on all visible rows at the same time can only have a single parameter, this parameter denotes the value that will be sent when the row has been selected."));
3383             }
3384         }
3385         catch (Throwable th)
3386         {
3387             Throwable cause = th.getCause();
3388             int depth = 0; // Some throwables have infinite recursion
3389             while (cause != null && depth < 7)
3390             {
3391                 th = cause;
3392                 depth++;
3393             }
3394             logger.error("Error validating constraint 'org::andromda::cartridges::bpm4struts::metafacades::StrutsParameter::table actions must all have one parameter' ON "
3395                 + this.THIS().toString() + ": " + th.getMessage(), th);
3396         }
3397         try
3398         {
3399             final Object contextElement = this.THIS();
3400             boolean constraintValid = OCLResultEnsurer.ensure((Boolean.valueOf(String.valueOf(OCLCollections.notEmpty(OCLIntrospector.invoke(contextElement,"tableGlobalActions")))).booleanValue()?Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"allGlobalTableActionsHaveSameParameter"))).booleanValue():true));
3401             if (!constraintValid)
3402             {
3403                 validationMessages.add(
3404                     new ModelValidationMessage(
3405                         (MetafacadeBase)contextElement ,
3406                         "org::andromda::cartridges::bpm4struts::metafacades::StrutsParameter::all global table action must have the same parameter",
3407                         "All actions targetting this table and operating on the entire rowset must have the same event parameter declaration, this means both name and type must match for all parameters in these actions."));
3408             }
3409         }
3410         catch (Throwable th)
3411         {
3412             Throwable cause = th.getCause();
3413             int depth = 0; // Some throwables have infinite recursion
3414             while (cause != null && depth < 7)
3415             {
3416                 th = cause;
3417                 depth++;
3418             }
3419             logger.error("Error validating constraint 'org::andromda::cartridges::bpm4struts::metafacades::StrutsParameter::all global table action must have the same parameter' ON "
3420                 + this.THIS().toString() + ": " + th.getMessage(), th);
3421         }
3422         try
3423         {
3424             final Object contextElement = this.THIS();
3425             boolean constraintValid = OCLResultEnsurer.ensure(OCLIntrospector.invoke(contextElement,"safeNamePresent"));
3426             if (!constraintValid)
3427             {
3428                 validationMessages.add(
3429                     new ModelValidationMessage(
3430                         (MetafacadeBase)contextElement ,
3431                         "org::andromda::cartridges::bpm4struts::metafacades::StrutsManageableEntityAttribute::SAFE NAME - TO BE REMOVED LATER",
3432                         "The names you give to fields cannot start with a lowercase character directly followed by a character in uppercase. This is due to a bug in the Jakarta commons library which is used by Struts. The behavior of that library is inconsistent with the reflection API provided by the JDK. Please rename this field or you'll get exceptions when running your web application."));
3433             }
3434         }
3435         catch (Throwable th)
3436         {
3437             Throwable cause = th.getCause();
3438             int depth = 0; // Some throwables have infinite recursion
3439             while (cause != null && depth < 7)
3440             {
3441                 th = cause;
3442                 depth++;
3443             }
3444             logger.error("Error validating constraint 'org::andromda::cartridges::bpm4struts::metafacades::StrutsManageableEntityAttribute::SAFE NAME - TO BE REMOVED LATER' ON "
3445                 + this.THIS().toString() + ": " + th.getMessage(), th);
3446         }
3447     }
3448 
3449     /**
3450      * The property that stores the name of the metafacade.
3451      */
3452     private static final String NAME_PROPERTY = "name";
3453     private static final String FQNAME_PROPERTY = "fullyQualifiedName";
3454 
3455     /**
3456      * @see Object#toString()
3457      */
3458     @Override
3459     public String toString()
3460     {
3461         final StringBuilder toString = new StringBuilder(this.getClass().getName());
3462         toString.append("[");
3463         try
3464         {
3465             toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY));
3466         }
3467         catch (final Throwable tryAgain)
3468         {
3469             try
3470             {
3471                 toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY));
3472             }
3473             catch (final Throwable ignore)
3474             {
3475                 // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property
3476             }
3477         }
3478         toString.append("]");
3479         return toString.toString();
3480     }
3481 }