001// license-header java merge-point
002//
003// Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
004//
005package org.andromda.cartridges.jsf2.metafacades;
006
007import java.util.Collection;
008import org.andromda.core.common.Introspector;
009import org.andromda.core.metafacade.MetafacadeBase;
010import org.andromda.core.metafacade.MetafacadeFactory;
011import org.andromda.core.metafacade.ModelValidationMessage;
012import org.andromda.metafacades.uml.AttributeFacade;
013import org.andromda.metafacades.uml.ClassifierFacade;
014import org.andromda.metafacades.uml.ConstraintFacade;
015import org.andromda.metafacades.uml.DependencyFacade;
016import org.andromda.metafacades.uml.EnumerationFacade;
017import org.andromda.metafacades.uml.FrontEndParameter;
018import org.andromda.metafacades.uml.ModelElementFacade;
019import org.andromda.metafacades.uml.ModelFacade;
020import org.andromda.metafacades.uml.PackageFacade;
021import org.andromda.metafacades.uml.ParameterFacade;
022import org.andromda.metafacades.uml.StateMachineFacade;
023import org.andromda.metafacades.uml.StereotypeFacade;
024import org.andromda.metafacades.uml.TaggedValueFacade;
025import org.andromda.metafacades.uml.TemplateParameterFacade;
026import org.andromda.metafacades.uml.TypeMappings;
027
028/**
029 * Represents an attribute on a classifier used by a JSF application.
030 * MetafacadeLogic for JSFAttribute
031 *
032 * @see JSFAttribute
033 */
034public abstract class JSFAttributeLogic
035    extends MetafacadeBase
036    implements JSFAttribute
037{
038    /**
039     * The underlying UML object
040     * @see Object
041     */
042    protected Object metaObject;
043
044    /** Create Metafacade implementation instance using the MetafacadeFactory from the context
045     * @param metaObjectIn
046     * @param context
047     */
048    protected JSFAttributeLogic(Object metaObjectIn, String context)
049    {
050        super(metaObjectIn, getContext(context));
051        this.superAttributeFacade =
052           (AttributeFacade)
053            MetafacadeFactory.getInstance().createFacadeImpl(
054                    "org.andromda.metafacades.uml.AttributeFacade",
055                    metaObjectIn,
056                    getContext(context));
057        this.metaObject = metaObjectIn;
058    }
059
060    /**
061     * Gets the context for this metafacade logic instance.
062     * @param context String. Set to JSFAttribute if null
063     * @return context String
064     */
065    private static String getContext(String context)
066    {
067        if (context == null)
068        {
069            context = "org.andromda.cartridges.jsf2.metafacades.JSFAttribute";
070        }
071        return context;
072    }
073
074    private AttributeFacade superAttributeFacade;
075    private boolean superAttributeFacadeInitialized = false;
076
077    /**
078     * Gets the AttributeFacade parent instance.
079     * @return this.superAttributeFacade AttributeFacade
080     */
081    private AttributeFacade getSuperAttributeFacade()
082    {
083        if (!this.superAttributeFacadeInitialized)
084        {
085            ((MetafacadeBase)this.superAttributeFacade).setMetafacadeContext(this.getMetafacadeContext());
086            this.superAttributeFacadeInitialized = true;
087        }
088        return this.superAttributeFacade;
089    }
090
091    /** Reset context only for non-root metafacades
092     * @param context
093     * @see org.andromda.core.metafacade.MetafacadeBase#resetMetafacadeContext(String context)
094     */
095    @Override
096    public void resetMetafacadeContext(String context)
097    {
098        if (!this.contextRoot) // reset context only for non-root metafacades
099        {
100            context = getContext(context);  // to have same value as in original constructor call
101            setMetafacadeContext (context);
102            if (this.superAttributeFacadeInitialized)
103            {
104                ((MetafacadeBase)this.superAttributeFacade).resetMetafacadeContext(context);
105            }
106        }
107    }
108
109    /**
110     * @return boolean true always
111     * @see JSFAttribute
112     */
113    public boolean isJSFAttributeMetaType()
114    {
115        return true;
116    }
117
118    // --------------- attributes ---------------------
119
120   /**
121    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getMessageKey()
122    * @return String
123    */
124    protected abstract String handleGetMessageKey();
125
126    private String __messageKey1a;
127    private boolean __messageKey1aSet = false;
128
129    /**
130     * The message key for this attribute.
131     * @return (String)handleGetMessageKey()
132     */
133    public final String getMessageKey()
134    {
135        String messageKey1a = this.__messageKey1a;
136        if (!this.__messageKey1aSet)
137        {
138            // messageKey has no pre constraints
139            messageKey1a = handleGetMessageKey();
140            // messageKey has no post constraints
141            this.__messageKey1a = messageKey1a;
142            if (isMetafacadePropertyCachingEnabled())
143            {
144                this.__messageKey1aSet = true;
145            }
146        }
147        return messageKey1a;
148    }
149
150   /**
151    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getMessageValue()
152    * @return String
153    */
154    protected abstract String handleGetMessageValue();
155
156    private String __messageValue2a;
157    private boolean __messageValue2aSet = false;
158
159    /**
160     * The default value for the message key.
161     * @return (String)handleGetMessageValue()
162     */
163    public final String getMessageValue()
164    {
165        String messageValue2a = this.__messageValue2a;
166        if (!this.__messageValue2aSet)
167        {
168            // messageValue has no pre constraints
169            messageValue2a = handleGetMessageValue();
170            // messageValue has no post constraints
171            this.__messageValue2a = messageValue2a;
172            if (isMetafacadePropertyCachingEnabled())
173            {
174                this.__messageValue2aSet = true;
175            }
176        }
177        return messageValue2a;
178    }
179
180   /**
181    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getDummyValue()
182    * @return String
183    */
184    protected abstract String handleGetDummyValue();
185
186    private String __dummyValue3a;
187    private boolean __dummyValue3aSet = false;
188
189    /**
190     * The dummy value to give the attribute when creating a dummy instance of this attribute's
191     * owner.
192     * @return (String)handleGetDummyValue()
193     */
194    public final String getDummyValue()
195    {
196        String dummyValue3a = this.__dummyValue3a;
197        if (!this.__dummyValue3aSet)
198        {
199            // dummyValue has no pre constraints
200            dummyValue3a = handleGetDummyValue();
201            // dummyValue has no post constraints
202            this.__dummyValue3a = dummyValue3a;
203            if (isMetafacadePropertyCachingEnabled())
204            {
205                this.__dummyValue3aSet = true;
206            }
207        }
208        return dummyValue3a;
209    }
210
211   /**
212    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getFormat()
213    * @return String
214    */
215    protected abstract String handleGetFormat();
216
217    private String __format4a;
218    private boolean __format4aSet = false;
219
220    /**
221     * If this attributes represents a date or time this method will return the format in which it
222     * must be represented. In the event this format has not been specified by the any tagged value
223     * the default will be used.
224     * @return (String)handleGetFormat()
225     */
226    public final String getFormat()
227    {
228        String format4a = this.__format4a;
229        if (!this.__format4aSet)
230        {
231            // format has no pre constraints
232            format4a = handleGetFormat();
233            // format has no post constraints
234            this.__format4a = format4a;
235            if (isMetafacadePropertyCachingEnabled())
236            {
237                this.__format4aSet = true;
238            }
239        }
240        return format4a;
241    }
242
243   /**
244    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputTextarea()
245    * @return boolean
246    */
247    protected abstract boolean handleIsInputTextarea();
248
249    private boolean __inputTextarea5a;
250    private boolean __inputTextarea5aSet = false;
251
252    /**
253     * Indicates if this parameter represents as an input text area widget.
254     * @return (boolean)handleIsInputTextarea()
255     */
256    public final boolean isInputTextarea()
257    {
258        boolean inputTextarea5a = this.__inputTextarea5a;
259        if (!this.__inputTextarea5aSet)
260        {
261            // inputTextarea has no pre constraints
262            inputTextarea5a = handleIsInputTextarea();
263            // inputTextarea has no post constraints
264            this.__inputTextarea5a = inputTextarea5a;
265            if (isMetafacadePropertyCachingEnabled())
266            {
267                this.__inputTextarea5aSet = true;
268            }
269        }
270        return inputTextarea5a;
271    }
272
273   /**
274    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputText()
275    * @return boolean
276    */
277    protected abstract boolean handleIsInputText();
278
279    private boolean __inputText6a;
280    private boolean __inputText6aSet = false;
281
282    /**
283     * Indicates whether or not this parameter should be rendered as a text input widget.
284     * @return (boolean)handleIsInputText()
285     */
286    public final boolean isInputText()
287    {
288        boolean inputText6a = this.__inputText6a;
289        if (!this.__inputText6aSet)
290        {
291            // inputText has no pre constraints
292            inputText6a = handleIsInputText();
293            // inputText has no post constraints
294            this.__inputText6a = inputText6a;
295            if (isMetafacadePropertyCachingEnabled())
296            {
297                this.__inputText6aSet = true;
298            }
299        }
300        return inputText6a;
301    }
302
303   /**
304    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputSecret()
305    * @return boolean
306    */
307    protected abstract boolean handleIsInputSecret();
308
309    private boolean __inputSecret7a;
310    private boolean __inputSecret7aSet = false;
311
312    /**
313     * Indicates whether or not this parameter represents an input "secret" widget (i.e. password).
314     * @return (boolean)handleIsInputSecret()
315     */
316    public final boolean isInputSecret()
317    {
318        boolean inputSecret7a = this.__inputSecret7a;
319        if (!this.__inputSecret7aSet)
320        {
321            // inputSecret has no pre constraints
322            inputSecret7a = handleIsInputSecret();
323            // inputSecret has no post constraints
324            this.__inputSecret7a = inputSecret7a;
325            if (isMetafacadePropertyCachingEnabled())
326            {
327                this.__inputSecret7aSet = true;
328            }
329        }
330        return inputSecret7a;
331    }
332
333   /**
334    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputSelect()
335    * @return boolean
336    */
337    protected abstract boolean handleIsInputSelect();
338
339    private boolean __inputSelect8a;
340    private boolean __inputSelect8aSet = false;
341
342    /**
343     * Indicates whether or not this parameter represents an input select widget.
344     * @return (boolean)handleIsInputSelect()
345     */
346    public final boolean isInputSelect()
347    {
348        boolean inputSelect8a = this.__inputSelect8a;
349        if (!this.__inputSelect8aSet)
350        {
351            // inputSelect has no pre constraints
352            inputSelect8a = handleIsInputSelect();
353            // inputSelect has no post constraints
354            this.__inputSelect8a = inputSelect8a;
355            if (isMetafacadePropertyCachingEnabled())
356            {
357                this.__inputSelect8aSet = true;
358            }
359        }
360        return inputSelect8a;
361    }
362
363   /**
364    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputRadio()
365    * @return boolean
366    */
367    protected abstract boolean handleIsInputRadio();
368
369    private boolean __inputRadio9a;
370    private boolean __inputRadio9aSet = false;
371
372    /**
373     * Indicates whether or not this parameter should be rendered as an input radio widget.
374     * @return (boolean)handleIsInputRadio()
375     */
376    public final boolean isInputRadio()
377    {
378        boolean inputRadio9a = this.__inputRadio9a;
379        if (!this.__inputRadio9aSet)
380        {
381            // inputRadio has no pre constraints
382            inputRadio9a = handleIsInputRadio();
383            // inputRadio has no post constraints
384            this.__inputRadio9a = inputRadio9a;
385            if (isMetafacadePropertyCachingEnabled())
386            {
387                this.__inputRadio9aSet = true;
388            }
389        }
390        return inputRadio9a;
391    }
392
393   /**
394    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputMultibox()
395    * @return boolean
396    */
397    protected abstract boolean handleIsInputMultibox();
398
399    private boolean __inputMultibox10a;
400    private boolean __inputMultibox10aSet = false;
401
402    /**
403     * Indicates whether or not this type represents an input multibox.
404     * @return (boolean)handleIsInputMultibox()
405     */
406    public final boolean isInputMultibox()
407    {
408        boolean inputMultibox10a = this.__inputMultibox10a;
409        if (!this.__inputMultibox10aSet)
410        {
411            // inputMultibox has no pre constraints
412            inputMultibox10a = handleIsInputMultibox();
413            // inputMultibox has no post constraints
414            this.__inputMultibox10a = inputMultibox10a;
415            if (isMetafacadePropertyCachingEnabled())
416            {
417                this.__inputMultibox10aSet = true;
418            }
419        }
420        return inputMultibox10a;
421    }
422
423   /**
424    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputHidden()
425    * @return boolean
426    */
427    protected abstract boolean handleIsInputHidden();
428
429    private boolean __inputHidden11a;
430    private boolean __inputHidden11aSet = false;
431
432    /**
433     * Indicates whether or not this parameter represents a hidden input widget.
434     * @return (boolean)handleIsInputHidden()
435     */
436    public final boolean isInputHidden()
437    {
438        boolean inputHidden11a = this.__inputHidden11a;
439        if (!this.__inputHidden11aSet)
440        {
441            // inputHidden has no pre constraints
442            inputHidden11a = handleIsInputHidden();
443            // inputHidden has no post constraints
444            this.__inputHidden11a = inputHidden11a;
445            if (isMetafacadePropertyCachingEnabled())
446            {
447                this.__inputHidden11aSet = true;
448            }
449        }
450        return inputHidden11a;
451    }
452
453   /**
454    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputFile()
455    * @return boolean
456    */
457    protected abstract boolean handleIsInputFile();
458
459    private boolean __inputFile12a;
460    private boolean __inputFile12aSet = false;
461
462    /**
463     * Indicates whether or not this is a file input type.
464     * @return (boolean)handleIsInputFile()
465     */
466    public final boolean isInputFile()
467    {
468        boolean inputFile12a = this.__inputFile12a;
469        if (!this.__inputFile12aSet)
470        {
471            // inputFile has no pre constraints
472            inputFile12a = handleIsInputFile();
473            // inputFile has no post constraints
474            this.__inputFile12a = inputFile12a;
475            if (isMetafacadePropertyCachingEnabled())
476            {
477                this.__inputFile12aSet = true;
478            }
479        }
480        return inputFile12a;
481    }
482
483   /**
484    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputCheckbox()
485    * @return boolean
486    */
487    protected abstract boolean handleIsInputCheckbox();
488
489    private boolean __inputCheckbox13a;
490    private boolean __inputCheckbox13aSet = false;
491
492    /**
493     * Indicates if this parameter represents a checkbox widget.
494     * @return (boolean)handleIsInputCheckbox()
495     */
496    public final boolean isInputCheckbox()
497    {
498        boolean inputCheckbox13a = this.__inputCheckbox13a;
499        if (!this.__inputCheckbox13aSet)
500        {
501            // inputCheckbox has no pre constraints
502            inputCheckbox13a = handleIsInputCheckbox();
503            // inputCheckbox has no post constraints
504            this.__inputCheckbox13a = inputCheckbox13a;
505            if (isMetafacadePropertyCachingEnabled())
506            {
507                this.__inputCheckbox13aSet = true;
508            }
509        }
510        return inputCheckbox13a;
511    }
512
513   /**
514    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getValueListDummyValue()
515    * @return String
516    */
517    protected abstract String handleGetValueListDummyValue();
518
519    private String __valueListDummyValue14a;
520    private boolean __valueListDummyValue14aSet = false;
521
522    /**
523     * The dummy value for a value list.
524     * @return (String)handleGetValueListDummyValue()
525     */
526    public final String getValueListDummyValue()
527    {
528        String valueListDummyValue14a = this.__valueListDummyValue14a;
529        if (!this.__valueListDummyValue14aSet)
530        {
531            // valueListDummyValue has no pre constraints
532            valueListDummyValue14a = handleGetValueListDummyValue();
533            // valueListDummyValue has no post constraints
534            this.__valueListDummyValue14a = valueListDummyValue14a;
535            if (isMetafacadePropertyCachingEnabled())
536            {
537                this.__valueListDummyValue14aSet = true;
538            }
539        }
540        return valueListDummyValue14a;
541    }
542
543   /**
544    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getValidWhen()
545    * @return String
546    */
547    protected abstract String handleGetValidWhen();
548
549    private String __validWhen15a;
550    private boolean __validWhen15aSet = false;
551
552    /**
553     * The validator's 'validwhen' value, this is useful when the validation of a parameter depends
554     * on the validation of others. See the apache commons-validator documentation for more
555     * information.
556     * @return (String)handleGetValidWhen()
557     */
558    public final String getValidWhen()
559    {
560        String validWhen15a = this.__validWhen15a;
561        if (!this.__validWhen15aSet)
562        {
563            // validWhen has no pre constraints
564            validWhen15a = handleGetValidWhen();
565            // validWhen has no post constraints
566            this.__validWhen15a = validWhen15a;
567            if (isMetafacadePropertyCachingEnabled())
568            {
569                this.__validWhen15aSet = true;
570            }
571        }
572        return validWhen15a;
573    }
574
575   /**
576    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getValidatorTypes()
577    * @return Collection
578    */
579    protected abstract Collection handleGetValidatorTypes();
580
581    private Collection __validatorTypes16a;
582    private boolean __validatorTypes16aSet = false;
583
584    /**
585     * All validator types for this attribute.
586     * @return (Collection)handleGetValidatorTypes()
587     */
588    public final Collection getValidatorTypes()
589    {
590        Collection validatorTypes16a = this.__validatorTypes16a;
591        if (!this.__validatorTypes16aSet)
592        {
593            // validatorTypes has no pre constraints
594            validatorTypes16a = handleGetValidatorTypes();
595            // validatorTypes has no post constraints
596            this.__validatorTypes16a = validatorTypes16a;
597            if (isMetafacadePropertyCachingEnabled())
598            {
599                this.__validatorTypes16aSet = true;
600            }
601        }
602        return validatorTypes16a;
603    }
604
605   /**
606    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isValidationRequired()
607    * @return boolean
608    */
609    protected abstract boolean handleIsValidationRequired();
610
611    private boolean __validationRequired17a;
612    private boolean __validationRequired17aSet = false;
613
614    /**
615     * Indicates whether or not this attribute requires some kind of validation (the collection of
616     * validator types is not empty).
617     * @return (boolean)handleIsValidationRequired()
618     */
619    public final boolean isValidationRequired()
620    {
621        boolean validationRequired17a = this.__validationRequired17a;
622        if (!this.__validationRequired17aSet)
623        {
624            // validationRequired has no pre constraints
625            validationRequired17a = handleIsValidationRequired();
626            // validationRequired has no post constraints
627            this.__validationRequired17a = validationRequired17a;
628            if (isMetafacadePropertyCachingEnabled())
629            {
630                this.__validationRequired17aSet = true;
631            }
632        }
633        return validationRequired17a;
634    }
635
636   /**
637    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isStrictDateFormat()
638    * @return boolean
639    */
640    protected abstract boolean handleIsStrictDateFormat();
641
642    private boolean __strictDateFormat18a;
643    private boolean __strictDateFormat18aSet = false;
644
645    /**
646     * Indicates where or not the date format is to be strictly respected. Otherwise the date
647     * formatter used for the representation of this date is to be set to lenient.
648     * @return (boolean)handleIsStrictDateFormat()
649     */
650    public final boolean isStrictDateFormat()
651    {
652        boolean strictDateFormat18a = this.__strictDateFormat18a;
653        if (!this.__strictDateFormat18aSet)
654        {
655            // strictDateFormat has no pre constraints
656            strictDateFormat18a = handleIsStrictDateFormat();
657            // strictDateFormat has no post constraints
658            this.__strictDateFormat18a = strictDateFormat18a;
659            if (isMetafacadePropertyCachingEnabled())
660            {
661                this.__strictDateFormat18aSet = true;
662            }
663        }
664        return strictDateFormat18a;
665    }
666
667   /**
668    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isEqualValidator()
669    * @return boolean
670    */
671    protected abstract boolean handleIsEqualValidator();
672
673    private boolean __equalValidator19a;
674    private boolean __equalValidator19aSet = false;
675
676    /**
677     * Indicates whether or not this parameter uses the equal validator.
678     * @return (boolean)handleIsEqualValidator()
679     */
680    public final boolean isEqualValidator()
681    {
682        boolean equalValidator19a = this.__equalValidator19a;
683        if (!this.__equalValidator19aSet)
684        {
685            // equalValidator has no pre constraints
686            equalValidator19a = handleIsEqualValidator();
687            // equalValidator has no post constraints
688            this.__equalValidator19a = equalValidator19a;
689            if (isMetafacadePropertyCachingEnabled())
690            {
691                this.__equalValidator19aSet = true;
692            }
693        }
694        return equalValidator19a;
695    }
696
697   /**
698    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputTable()
699    * @return boolean
700    */
701    protected abstract boolean handleIsInputTable();
702
703    private boolean __inputTable20a;
704    private boolean __inputTable20aSet = false;
705
706    /**
707     * Indicates whether or not this is an table input type.
708     * @return (boolean)handleIsInputTable()
709     */
710    public final boolean isInputTable()
711    {
712        boolean inputTable20a = this.__inputTable20a;
713        if (!this.__inputTable20aSet)
714        {
715            // inputTable has no pre constraints
716            inputTable20a = handleIsInputTable();
717            // inputTable has no post constraints
718            this.__inputTable20a = inputTable20a;
719            if (isMetafacadePropertyCachingEnabled())
720            {
721                this.__inputTable20aSet = true;
722            }
723        }
724        return inputTable20a;
725    }
726
727   /**
728    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputTypePresent()
729    * @return boolean
730    */
731    protected abstract boolean handleIsInputTypePresent();
732
733    private boolean __inputTypePresent21a;
734    private boolean __inputTypePresent21aSet = false;
735
736    /**
737     * Indicates whether or not there is an input type defined for this attribute.
738     * @return (boolean)handleIsInputTypePresent()
739     */
740    public final boolean isInputTypePresent()
741    {
742        boolean inputTypePresent21a = this.__inputTypePresent21a;
743        if (!this.__inputTypePresent21aSet)
744        {
745            // inputTypePresent has no pre constraints
746            inputTypePresent21a = handleIsInputTypePresent();
747            // inputTypePresent has no post constraints
748            this.__inputTypePresent21a = inputTypePresent21a;
749            if (isMetafacadePropertyCachingEnabled())
750            {
751                this.__inputTypePresent21aSet = true;
752            }
753        }
754        return inputTypePresent21a;
755    }
756
757   /**
758    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isPlaintext()
759    * @return boolean
760    */
761    protected abstract boolean handleIsPlaintext();
762
763    private boolean __plaintext22a;
764    private boolean __plaintext22aSet = false;
765
766    /**
767     * Indicates whether or not this attribute's value should be rendered as plain text (not as a
768     * widget).
769     * @return (boolean)handleIsPlaintext()
770     */
771    public final boolean isPlaintext()
772    {
773        boolean plaintext22a = this.__plaintext22a;
774        if (!this.__plaintext22aSet)
775        {
776            // plaintext has no pre constraints
777            plaintext22a = handleIsPlaintext();
778            // plaintext has no post constraints
779            this.__plaintext22a = plaintext22a;
780            if (isMetafacadePropertyCachingEnabled())
781            {
782                this.__plaintext22aSet = true;
783            }
784        }
785        return plaintext22a;
786    }
787
788   /**
789    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getInputTableIdentifierColumns()
790    * @return String
791    */
792    protected abstract String handleGetInputTableIdentifierColumns();
793
794    private String __inputTableIdentifierColumns23a;
795    private boolean __inputTableIdentifierColumns23aSet = false;
796
797    /**
798     * A comma separated list of the input table identifier columns (these are the columns that
799     * uniquely define a row in an input table).
800     * @return (String)handleGetInputTableIdentifierColumns()
801     */
802    public final String getInputTableIdentifierColumns()
803    {
804        String inputTableIdentifierColumns23a = this.__inputTableIdentifierColumns23a;
805        if (!this.__inputTableIdentifierColumns23aSet)
806        {
807            // inputTableIdentifierColumns has no pre constraints
808            inputTableIdentifierColumns23a = handleGetInputTableIdentifierColumns();
809            // inputTableIdentifierColumns has no post constraints
810            this.__inputTableIdentifierColumns23a = inputTableIdentifierColumns23a;
811            if (isMetafacadePropertyCachingEnabled())
812            {
813                this.__inputTableIdentifierColumns23aSet = true;
814            }
815        }
816        return inputTableIdentifierColumns23a;
817    }
818
819   /**
820    * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getMaxLength()
821    * @return String
822    */
823    protected abstract String handleGetMaxLength();
824
825    private String __maxLength24a;
826    private boolean __maxLength24aSet = false;
827
828    /**
829     * The max length allowed in the input component
830     * @return (String)handleGetMaxLength()
831     */
832    public final String getMaxLength()
833    {
834        String maxLength24a = this.__maxLength24a;
835        if (!this.__maxLength24aSet)
836        {
837            // maxLength has no pre constraints
838            maxLength24a = handleGetMaxLength();
839            // maxLength has no post constraints
840            this.__maxLength24a = maxLength24a;
841            if (isMetafacadePropertyCachingEnabled())
842            {
843                this.__maxLength24aSet = true;
844            }
845        }
846        return maxLength24a;
847    }
848
849    // ---------------- business methods ----------------------
850
851    /**
852     * Method to be implemented in descendants
853     * Retrieves the name of the form property for this attribute by taking the name of the owner
854     * property.
855     * @param ownerParameter
856     * @return String
857     */
858    protected abstract String handleGetFormPropertyName(ParameterFacade ownerParameter);
859
860    /**
861     * Retrieves the name of the form property for this attribute by taking the name of the owner
862     * property.
863     * @param ownerParameter ParameterFacade
864     * The parent that is the owner of this parameter.
865     * @return handleGetFormPropertyName(ownerParameter)
866     */
867    public String getFormPropertyName(ParameterFacade ownerParameter)
868    {
869        // getFormPropertyName has no pre constraints
870        String returnValue = handleGetFormPropertyName(ownerParameter);
871        // getFormPropertyName has no post constraints
872        return returnValue;
873    }
874
875    /**
876     * Method to be implemented in descendants
877     * Gets the unique id of this attribute on the form.
878     * @param ownerParameter
879     * @return String
880     */
881    protected abstract String handleGetFormPropertyId(ParameterFacade ownerParameter);
882
883    /**
884     * Gets the unique id of this attribute on the form.
885     * @param ownerParameter ParameterFacade
886     * The parameter that is the owner of this attribute.
887     * @return handleGetFormPropertyId(ownerParameter)
888     */
889    public String getFormPropertyId(ParameterFacade ownerParameter)
890    {
891        // getFormPropertyId has no pre constraints
892        String returnValue = handleGetFormPropertyId(ownerParameter);
893        // getFormPropertyId has no post constraints
894        return returnValue;
895    }
896
897    /**
898     * Method to be implemented in descendants
899     * Gets backing list name for this attribute. This is useful if you want to be able to select
900     * the attribute value from a list (i.e. a drop-down select input type).
901     * @param ownerParameter
902     * @return String
903     */
904    protected abstract String handleGetBackingListName(ParameterFacade ownerParameter);
905
906    /**
907     * Gets backing list name for this attribute. This is useful if you want to be able to select
908     * the attribute value from a list (i.e. a drop-down select input type).
909     * @param ownerParameter ParameterFacade
910     * The parameter that is the owner of this attribute.
911     * @return handleGetBackingListName(ownerParameter)
912     */
913    public String getBackingListName(ParameterFacade ownerParameter)
914    {
915        // getBackingListName has no pre constraints
916        String returnValue = handleGetBackingListName(ownerParameter);
917        // getBackingListName has no post constraints
918        return returnValue;
919    }
920
921    /**
922     * Method to be implemented in descendants
923     * Gets the name of the label list for this parameter. The label list name is the name of the
924     * list storing the labels for the possible values of this attribute (typically used for the
925     * labels of a drop-down select lists).
926     * @param ownerParameter
927     * @return String
928     */
929    protected abstract String handleGetLabelListName(ParameterFacade ownerParameter);
930
931    /**
932     * Gets the name of the label list for this parameter. The label list name is the name of the
933     * list storing the labels for the possible values of this attribute (typically used for the
934     * labels of a drop-down select lists).
935     * @param ownerParameter ParameterFacade
936     * The parameter that is the owner of this attribute.
937     * @return handleGetLabelListName(ownerParameter)
938     */
939    public String getLabelListName(ParameterFacade ownerParameter)
940    {
941        // getLabelListName has no pre constraints
942        String returnValue = handleGetLabelListName(ownerParameter);
943        // getLabelListName has no post constraints
944        return returnValue;
945    }
946
947    /**
948     * Method to be implemented in descendants
949     * Gets the name of the value list for this parameter; this list stores the possible values that
950     * this attribute may be (typically used for the values of a drop-down select list).
951     * @param ownerParameter
952     * @return String
953     */
954    protected abstract String handleGetValueListName(ParameterFacade ownerParameter);
955
956    /**
957     * Gets the name of the value list for this parameter; this list stores the possible values that
958     * this attribute may be (typically used for the values of a drop-down select list).
959     * @param ownerParameter ParameterFacade
960     * The parameter that is the owner of this attribute.
961     * @return handleGetValueListName(ownerParameter)
962     */
963    public String getValueListName(ParameterFacade ownerParameter)
964    {
965        // getValueListName has no pre constraints
966        String returnValue = handleGetValueListName(ownerParameter);
967        // getValueListName has no post constraints
968        return returnValue;
969    }
970
971    /**
972     * Method to be implemented in descendants
973     * Indicates whether or not this attribute is selectable according to its 'ownerParameter'.
974     * @param ownerParameter
975     * @return boolean
976     */
977    protected abstract boolean handleIsSelectable(FrontEndParameter ownerParameter);
978
979    /**
980     * Indicates whether or not this attribute is selectable according to its 'ownerParameter'.
981     * @param ownerParameter FrontEndParameter
982     * The parameter that 'owns' this attribute.
983     * @return handleIsSelectable(ownerParameter)
984     */
985    public boolean isSelectable(FrontEndParameter ownerParameter)
986    {
987        // isSelectable has no pre constraints
988        boolean returnValue = handleIsSelectable(ownerParameter);
989        // isSelectable has no post constraints
990        return returnValue;
991    }
992
993    /**
994     * Method to be implemented in descendants
995     * Gets the arguments for this parameter's validators.
996     * @param validatorType
997     * @return Collection
998     */
999    protected abstract Collection handleGetValidatorArgs(String validatorType);
1000
1001    /**
1002     * Gets the arguments for this parameter's validators.
1003     * @param validatorType String
1004     * The type of validator.
1005     * @return handleGetValidatorArgs(validatorType)
1006     */
1007    public Collection getValidatorArgs(String validatorType)
1008    {
1009        // getValidatorArgs has no pre constraints
1010        Collection returnValue = handleGetValidatorArgs(validatorType);
1011        // getValidatorArgs has no post constraints
1012        return returnValue;
1013    }
1014
1015    /**
1016     * Method to be implemented in descendants
1017     * Gets the name of the date formatter for this attribute by constructing the name from the
1018     * 'ownerParameter' (if this attribute represents a date).
1019     * @param ownerParameter
1020     * @return String
1021     */
1022    protected abstract String handleGetDateFormatter(JSFParameter ownerParameter);
1023
1024    /**
1025     * Gets the name of the date formatter for this attribute by constructing the name from the
1026     * 'ownerParameter' (if this attribute represents a date).
1027     * @param ownerParameter JSFParameter
1028     * The parameter that is the 'owner' of this attribute.
1029     * @return handleGetDateFormatter(ownerParameter)
1030     */
1031    public String getDateFormatter(JSFParameter ownerParameter)
1032    {
1033        // getDateFormatter has no pre constraints
1034        String returnValue = handleGetDateFormatter(ownerParameter);
1035        // getDateFormatter has no post constraints
1036        return returnValue;
1037    }
1038
1039    /**
1040     * Method to be implemented in descendants
1041     * Gets the name of the time formatter (if this parameter represents a time).
1042     * @param ownerParameter
1043     * @return String
1044     */
1045    protected abstract String handleGetTimeFormatter(JSFParameter ownerParameter);
1046
1047    /**
1048     * Gets the name of the time formatter (if this parameter represents a time).
1049     * @param ownerParameter JSFParameter
1050     * The parameter that is the 'owner' of this attribute.
1051     * @return handleGetTimeFormatter(ownerParameter)
1052     */
1053    public String getTimeFormatter(JSFParameter ownerParameter)
1054    {
1055        // getTimeFormatter has no pre constraints
1056        String returnValue = handleGetTimeFormatter(ownerParameter);
1057        // getTimeFormatter has no post constraints
1058        return returnValue;
1059    }
1060
1061    /**
1062     * Method to be implemented in descendants
1063     * Constructs and returns the backing value name given the 'ownerParameter'.
1064     * @param ownerParameter
1065     * @return String
1066     */
1067    protected abstract String handleGetBackingValueName(ParameterFacade ownerParameter);
1068
1069    /**
1070     * Constructs and returns the backing value name given the 'ownerParameter'.
1071     * @param ownerParameter ParameterFacade
1072     * The parameter that is the "owner" of this attribute (i.e. the parameter's type contains this
1073     * attribute).
1074     * @return handleGetBackingValueName(ownerParameter)
1075     */
1076    public String getBackingValueName(ParameterFacade ownerParameter)
1077    {
1078        // getBackingValueName has no pre constraints
1079        String returnValue = handleGetBackingValueName(ownerParameter);
1080        // getBackingValueName has no post constraints
1081        return returnValue;
1082    }
1083
1084    /**
1085     * Method to be implemented in descendants
1086     * Indicates whether or not the backing value is required for this attribute (depending on the
1087     * 'ownerParameter').
1088     * @param ownerParameter
1089     * @return boolean
1090     */
1091    protected abstract boolean handleIsBackingValueRequired(FrontEndParameter ownerParameter);
1092
1093    /**
1094     * Indicates whether or not the backing value is required for this attribute (depending on the
1095     * 'ownerParameter').
1096     * @param ownerParameter FrontEndParameter
1097     * The 'owner' of this attribute (i.e. the attrubte who's type has this attribute).
1098     * @return handleIsBackingValueRequired(ownerParameter)
1099     */
1100    public boolean isBackingValueRequired(FrontEndParameter ownerParameter)
1101    {
1102        // isBackingValueRequired has no pre constraints
1103        boolean returnValue = handleIsBackingValueRequired(ownerParameter);
1104        // isBackingValueRequired has no post constraints
1105        return returnValue;
1106    }
1107
1108    /**
1109     * Method to be implemented in descendants
1110     * Gets the validator args for this attribute
1111     * @param ownerParameter
1112     * @return Collection
1113     */
1114    protected abstract Collection handleGetValidatorVars(JSFParameter ownerParameter);
1115
1116    /**
1117     * Gets the validator args for this attribute
1118     * @param ownerParameter JSFParameter
1119     * TODO: Model Documentation for
1120     * org.andromda.cartridges.jsf2.metafacades.JSFAttribute.getValidatorVars(ownerParameter)
1121     * @return handleGetValidatorVars(ownerParameter)
1122     */
1123    public Collection getValidatorVars(JSFParameter ownerParameter)
1124    {
1125        // getValidatorVars has no pre constraints
1126        Collection returnValue = handleGetValidatorVars(ownerParameter);
1127        // getValidatorVars has no post constraints
1128        return returnValue;
1129    }
1130
1131    /**
1132     * @return true
1133     * @see AttributeFacade
1134     */
1135    public boolean isAttributeFacadeMetaType()
1136    {
1137        return true;
1138    }
1139
1140    /**
1141     * @return true
1142     * @see ModelElementFacade
1143     */
1144    public boolean isModelElementFacadeMetaType()
1145    {
1146        return true;
1147    }
1148
1149    // ----------- delegates to AttributeFacade ------------
1150    /**
1151     * Searches the given feature for the specified tag.
1152     * If the follow boolean is set to true then the search will continue from the class attribute
1153     * to the class itself and then up the class hierarchy.
1154     * @see AttributeFacade#findTaggedValue(String name, boolean follow)
1155     */
1156    public Object findTaggedValue(String name, boolean follow)
1157    {
1158        return this.getSuperAttributeFacade().findTaggedValue(name, follow);
1159    }
1160
1161    /**
1162     * The default value of the attribute.  This is the value given if no value is defined.
1163     * @see AttributeFacade#getDefaultValue()
1164     */
1165    public String getDefaultValue()
1166    {
1167        return this.getSuperAttributeFacade().getDefaultValue();
1168    }
1169
1170    /**
1171     * If the attribute is an enumeration literal this represents the owning enumeration. Can be
1172     * empty.
1173     * @see AttributeFacade#getEnumeration()
1174     */
1175    public EnumerationFacade getEnumeration()
1176    {
1177        return this.getSuperAttributeFacade().getEnumeration();
1178    }
1179
1180    /**
1181     * Returns the enumeration literal parameters defined by tagged value as a comma separated list.
1182     * @see AttributeFacade#getEnumerationLiteralParameters()
1183     */
1184    public String getEnumerationLiteralParameters()
1185    {
1186        return this.getSuperAttributeFacade().getEnumerationLiteralParameters();
1187    }
1188
1189    /**
1190     * The value for this attribute if it is an enumeration literal, null otherwise. The default
1191     * value is returned as a String if it has been specified, if it's not specified this
1192     * attribute's name is assumed.
1193     * @see AttributeFacade#getEnumerationValue()
1194     */
1195    public String getEnumerationValue()
1196    {
1197        return this.getSuperAttributeFacade().getEnumerationValue();
1198    }
1199
1200    /**
1201     * The name of the accessor operation that would retrieve this attribute's value.
1202     * @see AttributeFacade#getGetterName()
1203     */
1204    public String getGetterName()
1205    {
1206        return this.getSuperAttributeFacade().getGetterName();
1207    }
1208
1209    /**
1210     * The name of the type that is returned on the accessor and mutator operations,  determined in
1211     * part by the multiplicity.
1212     * @see AttributeFacade#getGetterSetterTypeName()
1213     */
1214    public String getGetterSetterTypeName()
1215    {
1216        return this.getSuperAttributeFacade().getGetterSetterTypeName();
1217    }
1218
1219    /**
1220     * the lower value for the multiplicity
1221     * -only applicable for UML2
1222     * @see AttributeFacade#getLower()
1223     */
1224    public int getLower()
1225    {
1226        return this.getSuperAttributeFacade().getLower();
1227    }
1228
1229    /**
1230     * Gets the classifier who is the owner of the attributes.
1231     * @see AttributeFacade#getOwner()
1232     */
1233    public ClassifierFacade getOwner()
1234    {
1235        return this.getSuperAttributeFacade().getOwner();
1236    }
1237
1238    /**
1239     * The name of the mutator operation that would retrieve this attribute's value.
1240     * @see AttributeFacade#getSetterName()
1241     */
1242    public String getSetterName()
1243    {
1244        return this.getSuperAttributeFacade().getSetterName();
1245    }
1246
1247    /**
1248     * The classifier owning this attribute.
1249     * @see AttributeFacade#getType()
1250     */
1251    public ClassifierFacade getType()
1252    {
1253        return this.getSuperAttributeFacade().getType();
1254    }
1255
1256    /**
1257     * the upper value for the multiplicity (will be -1 for *)
1258     * -only applicable for UML2
1259     * @see AttributeFacade#getUpper()
1260     */
1261    public int getUpper()
1262    {
1263        return this.getSuperAttributeFacade().getUpper();
1264    }
1265
1266    /**
1267     * True if this attribute can only be set.
1268     * @see AttributeFacade#isAddOnly()
1269     */
1270    public boolean isAddOnly()
1271    {
1272        return this.getSuperAttributeFacade().isAddOnly();
1273    }
1274
1275    /**
1276     * True if this attribute can be modified.
1277     * @see AttributeFacade#isChangeable()
1278     */
1279    public boolean isChangeable()
1280    {
1281        return this.getSuperAttributeFacade().isChangeable();
1282    }
1283
1284    /**
1285     * Indicates if the default value is present.
1286     * @see AttributeFacade#isDefaultValuePresent()
1287     */
1288    public boolean isDefaultValuePresent()
1289    {
1290        return this.getSuperAttributeFacade().isDefaultValuePresent();
1291    }
1292
1293    /**
1294     * If the attribute is derived (its value is computed). UML2 only. UML14 always returns false.
1295     * Default=false.
1296     * @see AttributeFacade#isDerived()
1297     */
1298    public boolean isDerived()
1299    {
1300        return this.getSuperAttributeFacade().isDerived();
1301    }
1302
1303    /**
1304     * True if this attribute is owned by an enumeration.
1305     * @see AttributeFacade#isEnumerationLiteral()
1306     */
1307    public boolean isEnumerationLiteral()
1308    {
1309        return this.getSuperAttributeFacade().isEnumerationLiteral();
1310    }
1311
1312    /**
1313     * Returns true if enumeration literal parameters exist (defined by tagged value) for the
1314     * literal.
1315     * @see AttributeFacade#isEnumerationLiteralParametersExist()
1316     */
1317    public boolean isEnumerationLiteralParametersExist()
1318    {
1319        return this.getSuperAttributeFacade().isEnumerationLiteralParametersExist();
1320    }
1321
1322    /**
1323     * True if this attribute is owned by an enumeration but is defined as a member variable (NOT a
1324     * literal).
1325     * @see AttributeFacade#isEnumerationMember()
1326     */
1327    public boolean isEnumerationMember()
1328    {
1329        return this.getSuperAttributeFacade().isEnumerationMember();
1330    }
1331
1332    /**
1333     * IsLeaf property in the operation. If true, operation is final, cannot be extended or
1334     * implemented by a descendant.
1335     * @see AttributeFacade#isLeaf()
1336     */
1337    public boolean isLeaf()
1338    {
1339        return this.getSuperAttributeFacade().isLeaf();
1340    }
1341
1342    /**
1343     * Whether or not this attribute has a multiplicity greater than 1.
1344     * @see AttributeFacade#isMany()
1345     */
1346    public boolean isMany()
1347    {
1348        return this.getSuperAttributeFacade().isMany();
1349    }
1350
1351    /**
1352     * Indicates whether or not the attributes are ordered (if multiplicity is greater than 1).
1353     * @see AttributeFacade#isOrdered()
1354     */
1355    public boolean isOrdered()
1356    {
1357        return this.getSuperAttributeFacade().isOrdered();
1358    }
1359
1360    /**
1361     * Whether or not this attribute can be modified.
1362     * @see AttributeFacade#isReadOnly()
1363     */
1364    public boolean isReadOnly()
1365    {
1366        return this.getSuperAttributeFacade().isReadOnly();
1367    }
1368
1369    /**
1370     * Whether or not the multiplicity of this attribute is 1.
1371     * @see AttributeFacade#isRequired()
1372     */
1373    public boolean isRequired()
1374    {
1375        return this.getSuperAttributeFacade().isRequired();
1376    }
1377
1378    /**
1379     * Indicates if this attribute is 'static', meaning it has a classifier scope.
1380     * @see AttributeFacade#isStatic()
1381     */
1382    public boolean isStatic()
1383    {
1384        return this.getSuperAttributeFacade().isStatic();
1385    }
1386
1387    /**
1388     * If the attribute is unique within the Collection type. UML2 only. UML14 always returns false.
1389     * Unique+Ordered determines the implementation Collection type. Default=false.
1390     * @see AttributeFacade#isUnique()
1391     */
1392    public boolean isUnique()
1393    {
1394        return this.getSuperAttributeFacade().isUnique();
1395    }
1396
1397    /**
1398     * Copies all tagged values from the given ModelElementFacade to this model element facade.
1399     * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element)
1400     */
1401    public void copyTaggedValues(ModelElementFacade element)
1402    {
1403        this.getSuperAttributeFacade().copyTaggedValues(element);
1404    }
1405
1406    /**
1407     * Finds the tagged value with the specified 'tagName'. In case there are more values the first
1408     * one found will be returned.
1409     * @see ModelElementFacade#findTaggedValue(String tagName)
1410     */
1411    public Object findTaggedValue(String tagName)
1412    {
1413        return this.getSuperAttributeFacade().findTaggedValue(tagName);
1414    }
1415
1416    /**
1417     * Returns all the values for the tagged value with the specified name. The returned collection
1418     * will contains only String instances, or will be empty. Never null.
1419     * @see ModelElementFacade#findTaggedValues(String tagName)
1420     */
1421    public Collection<Object> findTaggedValues(String tagName)
1422    {
1423        return this.getSuperAttributeFacade().findTaggedValues(tagName);
1424    }
1425
1426    /**
1427     * Returns the fully qualified name of the model element. The fully qualified name includes
1428     * complete package qualified name of the underlying model element. The templates parameter will
1429     * be replaced by the correct one given the binding relation of the parameter to this element.
1430     * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement)
1431     */
1432    public String getBindedFullyQualifiedName(ModelElementFacade bindedElement)
1433    {
1434        return this.getSuperAttributeFacade().getBindedFullyQualifiedName(bindedElement);
1435    }
1436
1437    /**
1438     * Gets all constraints belonging to the model element.
1439     * @see ModelElementFacade#getConstraints()
1440     */
1441    public Collection<ConstraintFacade> getConstraints()
1442    {
1443        return this.getSuperAttributeFacade().getConstraints();
1444    }
1445
1446    /**
1447     * Returns the constraints of the argument kind that have been placed onto this model. Typical
1448     * kinds are "inv", "pre" and "post". Other kinds are possible.
1449     * @see ModelElementFacade#getConstraints(String kind)
1450     */
1451    public Collection<ConstraintFacade> getConstraints(String kind)
1452    {
1453        return this.getSuperAttributeFacade().getConstraints(kind);
1454    }
1455
1456    /**
1457     * Gets the documentation for the model element, The indent argument is prefixed to each line.
1458     * By default this method wraps lines after 64 characters.
1459     * This method is equivalent to <code>getDocumentation(indent, 64)</code>.
1460     * @see ModelElementFacade#getDocumentation(String indent)
1461     */
1462    public String getDocumentation(String indent)
1463    {
1464        return this.getSuperAttributeFacade().getDocumentation(indent);
1465    }
1466
1467    /**
1468     * This method returns the documentation for this model element, with the lines wrapped after
1469     * the specified number of characters, values of less than 1 will indicate no line wrapping is
1470     * required. By default paragraphs are returned as HTML.
1471     * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>.
1472     * @see ModelElementFacade#getDocumentation(String indent, int lineLength)
1473     */
1474    public String getDocumentation(String indent, int lineLength)
1475    {
1476        return this.getSuperAttributeFacade().getDocumentation(indent, lineLength);
1477    }
1478
1479    /**
1480     * This method returns the documentation for this model element, with the lines wrapped after
1481     * the specified number of characters, values of less than 1 will indicate no line wrapping is
1482     * required. HTML style determines if HTML Escaping is applied.
1483     * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle)
1484     */
1485    public String getDocumentation(String indent, int lineLength, boolean htmlStyle)
1486    {
1487        return this.getSuperAttributeFacade().getDocumentation(indent, lineLength, htmlStyle);
1488    }
1489
1490    /**
1491     * The fully qualified name of this model element.
1492     * @see ModelElementFacade#getFullyQualifiedName()
1493     */
1494    public String getFullyQualifiedName()
1495    {
1496        return this.getSuperAttributeFacade().getFullyQualifiedName();
1497    }
1498
1499    /**
1500     * Returns the fully qualified name of the model element. The fully qualified name includes
1501     * complete package qualified name of the underlying model element.  If modelName is true, then
1502     * the original name of the model element (the name contained within the model) will be the name
1503     * returned, otherwise a name from a language mapping will be returned.
1504     * @see ModelElementFacade#getFullyQualifiedName(boolean modelName)
1505     */
1506    public String getFullyQualifiedName(boolean modelName)
1507    {
1508        return this.getSuperAttributeFacade().getFullyQualifiedName(modelName);
1509    }
1510
1511    /**
1512     * Returns the fully qualified name as a path, the returned value always starts with out a slash
1513     * '/'.
1514     * @see ModelElementFacade#getFullyQualifiedNamePath()
1515     */
1516    public String getFullyQualifiedNamePath()
1517    {
1518        return this.getSuperAttributeFacade().getFullyQualifiedNamePath();
1519    }
1520
1521    /**
1522     * Gets the unique identifier of the underlying model element.
1523     * @see ModelElementFacade#getId()
1524     */
1525    public String getId()
1526    {
1527        return this.getSuperAttributeFacade().getId();
1528    }
1529
1530    /**
1531     * UML2: Retrieves the keywords for this element. Used to modify implementation properties which
1532     * are not represented by other properties, i.e. native, transient, volatile, synchronized,
1533     * (added annotations) override, deprecated. Can also be used to suppress compiler warnings:
1534     * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require
1535     * JDK5 compiler level.
1536     * @see ModelElementFacade#getKeywords()
1537     */
1538    public Collection<String> getKeywords()
1539    {
1540        return this.getSuperAttributeFacade().getKeywords();
1541    }
1542
1543    /**
1544     * UML2: Retrieves a localized label for this named element.
1545     * @see ModelElementFacade#getLabel()
1546     */
1547    public String getLabel()
1548    {
1549        return this.getSuperAttributeFacade().getLabel();
1550    }
1551
1552    /**
1553     * The language mappings that have been set for this model element.
1554     * @see ModelElementFacade#getLanguageMappings()
1555     */
1556    public TypeMappings getLanguageMappings()
1557    {
1558        return this.getSuperAttributeFacade().getLanguageMappings();
1559    }
1560
1561    /**
1562     * Return the model containing this model element (multiple models may be loaded and processed
1563     * at the same time).
1564     * @see ModelElementFacade#getModel()
1565     */
1566    public ModelFacade getModel()
1567    {
1568        return this.getSuperAttributeFacade().getModel();
1569    }
1570
1571    /**
1572     * The name of the model element.
1573     * @see ModelElementFacade#getName()
1574     */
1575    public String getName()
1576    {
1577        return this.getSuperAttributeFacade().getName();
1578    }
1579
1580    /**
1581     * Gets the package to which this model element belongs.
1582     * @see ModelElementFacade#getPackage()
1583     */
1584    public ModelElementFacade getPackage()
1585    {
1586        return this.getSuperAttributeFacade().getPackage();
1587    }
1588
1589    /**
1590     * The name of this model element's package.
1591     * @see ModelElementFacade#getPackageName()
1592     */
1593    public String getPackageName()
1594    {
1595        return this.getSuperAttributeFacade().getPackageName();
1596    }
1597
1598    /**
1599     * Gets the package name (optionally providing the ability to retrieve the model name and not
1600     * the mapped name).
1601     * @see ModelElementFacade#getPackageName(boolean modelName)
1602     */
1603    public String getPackageName(boolean modelName)
1604    {
1605        return this.getSuperAttributeFacade().getPackageName(modelName);
1606    }
1607
1608    /**
1609     * Returns the package as a path, the returned value always starts with out a slash '/'.
1610     * @see ModelElementFacade#getPackagePath()
1611     */
1612    public String getPackagePath()
1613    {
1614        return this.getSuperAttributeFacade().getPackagePath();
1615    }
1616
1617    /**
1618     * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the
1619     * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from
1620     * the names of the containing namespaces starting at the root of the hierarchy and ending with
1621     * the name of the NamedElement itself.
1622     * @see ModelElementFacade#getQualifiedName()
1623     */
1624    public String getQualifiedName()
1625    {
1626        return this.getSuperAttributeFacade().getQualifiedName();
1627    }
1628
1629    /**
1630     * Gets the root package for the model element.
1631     * @see ModelElementFacade#getRootPackage()
1632     */
1633    public PackageFacade getRootPackage()
1634    {
1635        return this.getSuperAttributeFacade().getRootPackage();
1636    }
1637
1638    /**
1639     * Gets the dependencies for which this model element is the source.
1640     * @see ModelElementFacade#getSourceDependencies()
1641     */
1642    public Collection<DependencyFacade> getSourceDependencies()
1643    {
1644        return this.getSuperAttributeFacade().getSourceDependencies();
1645    }
1646
1647    /**
1648     * If this model element is the context of an activity graph, this represents that activity
1649     * graph.
1650     * @see ModelElementFacade#getStateMachineContext()
1651     */
1652    public StateMachineFacade getStateMachineContext()
1653    {
1654        return this.getSuperAttributeFacade().getStateMachineContext();
1655    }
1656
1657    /**
1658     * The collection of ALL stereotype names for this model element.
1659     * @see ModelElementFacade#getStereotypeNames()
1660     */
1661    public Collection<String> getStereotypeNames()
1662    {
1663        return this.getSuperAttributeFacade().getStereotypeNames();
1664    }
1665
1666    /**
1667     * Gets all stereotypes for this model element.
1668     * @see ModelElementFacade#getStereotypes()
1669     */
1670    public Collection<StereotypeFacade> getStereotypes()
1671    {
1672        return this.getSuperAttributeFacade().getStereotypes();
1673    }
1674
1675    /**
1676     * Return the TaggedValues associated with this model element, under all stereotypes.
1677     * @see ModelElementFacade#getTaggedValues()
1678     */
1679    public Collection<TaggedValueFacade> getTaggedValues()
1680    {
1681        return this.getSuperAttributeFacade().getTaggedValues();
1682    }
1683
1684    /**
1685     * Gets the dependencies for which this model element is the target.
1686     * @see ModelElementFacade#getTargetDependencies()
1687     */
1688    public Collection<DependencyFacade> getTargetDependencies()
1689    {
1690        return this.getSuperAttributeFacade().getTargetDependencies();
1691    }
1692
1693    /**
1694     * Get the template parameter for this model element having the parameterName
1695     * @see ModelElementFacade#getTemplateParameter(String parameterName)
1696     */
1697    public Object getTemplateParameter(String parameterName)
1698    {
1699        return this.getSuperAttributeFacade().getTemplateParameter(parameterName);
1700    }
1701
1702    /**
1703     * Get the template parameters for this model element
1704     * @see ModelElementFacade#getTemplateParameters()
1705     */
1706    public Collection<TemplateParameterFacade> getTemplateParameters()
1707    {
1708        return this.getSuperAttributeFacade().getTemplateParameters();
1709    }
1710
1711    /**
1712     * The visibility (i.e. public, private, protected or package) of the model element, will
1713     * attempt a lookup for these values in the language mappings (if any).
1714     * @see ModelElementFacade#getVisibility()
1715     */
1716    public String getVisibility()
1717    {
1718        return this.getSuperAttributeFacade().getVisibility();
1719    }
1720
1721    /**
1722     * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance
1723     * is taken into account when searching for the stereotype), false otherwise.
1724     * @see ModelElementFacade#hasExactStereotype(String stereotypeName)
1725     */
1726    public boolean hasExactStereotype(String stereotypeName)
1727    {
1728        return this.getSuperAttributeFacade().hasExactStereotype(stereotypeName);
1729    }
1730
1731    /**
1732     * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma,
1733     * pipe, semicolon, or << >>
1734     * @see ModelElementFacade#hasKeyword(String keywordName)
1735     */
1736    public boolean hasKeyword(String keywordName)
1737    {
1738        return this.getSuperAttributeFacade().hasKeyword(keywordName);
1739    }
1740
1741    /**
1742     * Returns true if the model element has the specified stereotype.  If the stereotype itself
1743     * does not match, then a search will be made up the stereotype inheritance hierarchy, and if
1744     * one of the stereotype's ancestors has a matching name this method will return true, false
1745     * otherwise.
1746     * For example, if we have a certain stereotype called <<exception>> and a model element has a
1747     * stereotype called <<applicationException>> which extends <<exception>>, when calling this
1748     * method with 'stereotypeName' defined as 'exception' the method would return true since
1749     * <<applicationException>> inherits from <<exception>>.  If you want to check if the model
1750     * element has the exact stereotype, then use the method 'hasExactStereotype' instead.
1751     * @see ModelElementFacade#hasStereotype(String stereotypeName)
1752     */
1753    public boolean hasStereotype(String stereotypeName)
1754    {
1755        return this.getSuperAttributeFacade().hasStereotype(stereotypeName);
1756    }
1757
1758    /**
1759     * True if there are target dependencies from this element that are instances of BindingFacade.
1760     * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies.
1761     * @see ModelElementFacade#isBindingDependenciesPresent()
1762     */
1763    public boolean isBindingDependenciesPresent()
1764    {
1765        return this.getSuperAttributeFacade().isBindingDependenciesPresent();
1766    }
1767
1768    /**
1769     * Indicates if any constraints are present on this model element.
1770     * @see ModelElementFacade#isConstraintsPresent()
1771     */
1772    public boolean isConstraintsPresent()
1773    {
1774        return this.getSuperAttributeFacade().isConstraintsPresent();
1775    }
1776
1777    /**
1778     * Indicates if any documentation is present on this model element.
1779     * @see ModelElementFacade#isDocumentationPresent()
1780     */
1781    public boolean isDocumentationPresent()
1782    {
1783        return this.getSuperAttributeFacade().isDocumentationPresent();
1784    }
1785
1786    /**
1787     * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript.
1788     * @see ModelElementFacade#isReservedWord()
1789     */
1790    public boolean isReservedWord()
1791    {
1792        return this.getSuperAttributeFacade().isReservedWord();
1793    }
1794
1795    /**
1796     * True is there are template parameters on this model element. For UML2, applies to Class,
1797     * Operation, Property, and Parameter.
1798     * @see ModelElementFacade#isTemplateParametersPresent()
1799     */
1800    public boolean isTemplateParametersPresent()
1801    {
1802        return this.getSuperAttributeFacade().isTemplateParametersPresent();
1803    }
1804
1805    /**
1806     * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++,
1807     * JavaScript. Contains no spaces, special characters etc. Constraint always applied on
1808     * Enumerations and Interfaces, optionally applies on other model elements.
1809     * @see ModelElementFacade#isValidIdentifierName()
1810     */
1811    public boolean isValidIdentifierName()
1812    {
1813        return this.getSuperAttributeFacade().isValidIdentifierName();
1814    }
1815
1816    /**
1817     * Searches for the constraint with the specified 'name' on this model element, and if found
1818     * translates it using the specified 'translation' from a translation library discovered by the
1819     * framework.
1820     * @see ModelElementFacade#translateConstraint(String name, String translation)
1821     */
1822    public String translateConstraint(String name, String translation)
1823    {
1824        return this.getSuperAttributeFacade().translateConstraint(name, translation);
1825    }
1826
1827    /**
1828     * Translates all constraints belonging to this model element with the given 'translation'.
1829     * @see ModelElementFacade#translateConstraints(String translation)
1830     */
1831    public String[] translateConstraints(String translation)
1832    {
1833        return this.getSuperAttributeFacade().translateConstraints(translation);
1834    }
1835
1836    /**
1837     * Translates the constraints of the specified 'kind' belonging to this model element.
1838     * @see ModelElementFacade#translateConstraints(String kind, String translation)
1839     */
1840    public String[] translateConstraints(String kind, String translation)
1841    {
1842        return this.getSuperAttributeFacade().translateConstraints(kind, translation);
1843    }
1844
1845    /**
1846     * @see org.andromda.core.metafacade.MetafacadeBase#initialize()
1847     */
1848    @Override
1849    public void initialize()
1850    {
1851        this.getSuperAttributeFacade().initialize();
1852    }
1853
1854    /**
1855     * @return Object getSuperAttributeFacade().getValidationOwner()
1856     * @see org.andromda.core.metafacade.MetafacadeBase#getValidationOwner()
1857     */
1858    @Override
1859    public Object getValidationOwner()
1860    {
1861        Object owner = this.getSuperAttributeFacade().getValidationOwner();
1862        return owner;
1863    }
1864
1865    /**
1866     * @return String getSuperAttributeFacade().getValidationName()
1867     * @see org.andromda.core.metafacade.MetafacadeBase#getValidationName()
1868     */
1869    @Override
1870    public String getValidationName()
1871    {
1872        String name = this.getSuperAttributeFacade().getValidationName();
1873        return name;
1874    }
1875
1876    /**
1877     * @param validationMessages Collection<ModelValidationMessage>
1878     * @see org.andromda.core.metafacade.MetafacadeBase#validateInvariants(Collection validationMessages)
1879     */
1880    @Override
1881    public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
1882    {
1883        this.getSuperAttributeFacade().validateInvariants(validationMessages);
1884    }
1885
1886    /**
1887     * The property that stores the name of the metafacade.
1888     */
1889    private static final String NAME_PROPERTY = "name";
1890    private static final String FQNAME_PROPERTY = "fullyQualifiedName";
1891
1892    /**
1893     * @see Object#toString()
1894     */
1895    @Override
1896    public String toString()
1897    {
1898        final StringBuilder toString = new StringBuilder(this.getClass().getName());
1899        toString.append("[");
1900        try
1901        {
1902            toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY));
1903        }
1904        catch (final Throwable tryAgain)
1905        {
1906            try
1907            {
1908                toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY));
1909            }
1910            catch (final Throwable ignore)
1911            {
1912                // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property
1913            }
1914        }
1915        toString.append("]");
1916        return toString.toString();
1917    }
1918}