Source code

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 java.util.List;
009import org.andromda.core.common.Introspector;
010import org.andromda.core.metafacade.MetafacadeBase;
011import org.andromda.core.metafacade.MetafacadeFactory;
012import org.andromda.core.metafacade.ModelValidationMessage;
013import org.andromda.metafacades.uml.AssociationEndFacade;
014import org.andromda.metafacades.uml.AttributeFacade;
015import org.andromda.metafacades.uml.ClassifierFacade;
016import org.andromda.metafacades.uml.ConstraintFacade;
017import org.andromda.metafacades.uml.DependencyFacade;
018import org.andromda.metafacades.uml.FrontEndAction;
019import org.andromda.metafacades.uml.FrontEndController;
020import org.andromda.metafacades.uml.FrontEndUseCase;
021import org.andromda.metafacades.uml.GeneralizableElementFacade;
022import org.andromda.metafacades.uml.GeneralizationFacade;
023import org.andromda.metafacades.uml.ModelElementFacade;
024import org.andromda.metafacades.uml.ModelFacade;
025import org.andromda.metafacades.uml.OperationFacade;
026import org.andromda.metafacades.uml.PackageFacade;
027import org.andromda.metafacades.uml.StateMachineFacade;
028import org.andromda.metafacades.uml.StereotypeFacade;
029import org.andromda.metafacades.uml.TaggedValueFacade;
030import org.andromda.metafacades.uml.TemplateParameterFacade;
031import org.andromda.metafacades.uml.TypeMappings;
032import org.apache.log4j.Logger;
033
034/**
035 * Represents a controller for a JSF application.
036 * MetafacadeLogic for JSFController
037 *
038 * @see JSFController
039 */
040public abstract class JSFControllerLogic
041    extends MetafacadeBase
042    implements JSFController
043{
044    /**
045     * The underlying UML object
046     * @see Object
047     */
048    protected Object metaObject;
049
050    /** Create Metafacade implementation instance using the MetafacadeFactory from the context
051     * @param metaObjectIn
052     * @param context
053     */
054    protected JSFControllerLogic(Object metaObjectIn, String context)
055    {
056        super(metaObjectIn, getContext(context));
057        this.superFrontEndController =
058           (FrontEndController)
059            MetafacadeFactory.getInstance().createFacadeImpl(
060                    "org.andromda.metafacades.uml.FrontEndController",
061                    metaObjectIn,
062                    getContext(context));
063        this.metaObject = metaObjectIn;
064    }
065
066    /**
067     * The logger instance.
068     */
069    private static final Logger logger = Logger.getLogger(JSFControllerLogic.class);
070
071    /**
072     * Gets the context for this metafacade logic instance.
073     * @param context String. Set to JSFController if null
074     * @return context String
075     */
076    private static String getContext(String context)
077    {
078        if (context == null)
079        {
080            context = "org.andromda.cartridges.jsf2.metafacades.JSFController";
081        }
082        return context;
083    }
084
085    private FrontEndController superFrontEndController;
086    private boolean superFrontEndControllerInitialized = false;
087
088    /**
089     * Gets the FrontEndController parent instance.
090     * @return this.superFrontEndController FrontEndController
091     */
092    private FrontEndController getSuperFrontEndController()
093    {
094        if (!this.superFrontEndControllerInitialized)
095        {
096            ((MetafacadeBase)this.superFrontEndController).setMetafacadeContext(this.getMetafacadeContext());
097            this.superFrontEndControllerInitialized = true;
098        }
099        return this.superFrontEndController;
100    }
101
102    /** Reset context only for non-root metafacades
103     * @param context
104     * @see org.andromda.core.metafacade.MetafacadeBase#resetMetafacadeContext(String context)
105     */
106    @Override
107    public void resetMetafacadeContext(String context)
108    {
109        if (!this.contextRoot) // reset context only for non-root metafacades
110        {
111            context = getContext(context);  // to have same value as in original constructor call
112            setMetafacadeContext (context);
113            if (this.superFrontEndControllerInitialized)
114            {
115                ((MetafacadeBase)this.superFrontEndController).resetMetafacadeContext(context);
116            }
117        }
118    }
119
120    /**
121     * @return boolean true always
122     * @see JSFController
123     */
124    public boolean isJSFControllerMetaType()
125    {
126        return true;
127    }
128
129    // --------------- attributes ---------------------
130
131   /**
132    * @see org.andromda.cartridges.jsf2.metafacades.JSFController#getImplementationName()
133    * @return String
134    */
135    protected abstract String handleGetImplementationName();
136
137    private String __implementationName1a;
138    private boolean __implementationName1aSet = false;
139
140    /**
141     * The implementation name of this controller.
142     * @return (String)handleGetImplementationName()
143     */
144    public final String getImplementationName()
145    {
146        String implementationName1a = this.__implementationName1a;
147        if (!this.__implementationName1aSet)
148        {
149            // implementationName has no pre constraints
150            implementationName1a = handleGetImplementationName();
151            // implementationName has no post constraints
152            this.__implementationName1a = implementationName1a;
153            if (isMetafacadePropertyCachingEnabled())
154            {
155                this.__implementationName1aSet = true;
156            }
157        }
158        return implementationName1a;
159    }
160
161   /**
162    * @see org.andromda.cartridges.jsf2.metafacades.JSFController#getFullyQualifiedImplementationName()
163    * @return String
164    */
165    protected abstract String handleGetFullyQualifiedImplementationName();
166
167    private String __fullyQualifiedImplementationName2a;
168    private boolean __fullyQualifiedImplementationName2aSet = false;
169
170    /**
171     * The fully qualified implementation name of this controller.
172     * @return (String)handleGetFullyQualifiedImplementationName()
173     */
174    public final String getFullyQualifiedImplementationName()
175    {
176        String fullyQualifiedImplementationName2a = this.__fullyQualifiedImplementationName2a;
177        if (!this.__fullyQualifiedImplementationName2aSet)
178        {
179            // fullyQualifiedImplementationName has no pre constraints
180            fullyQualifiedImplementationName2a = handleGetFullyQualifiedImplementationName();
181            // fullyQualifiedImplementationName has no post constraints
182            this.__fullyQualifiedImplementationName2a = fullyQualifiedImplementationName2a;
183            if (isMetafacadePropertyCachingEnabled())
184            {
185                this.__fullyQualifiedImplementationName2aSet = true;
186            }
187        }
188        return fullyQualifiedImplementationName2a;
189    }
190
191   /**
192    * @see org.andromda.cartridges.jsf2.metafacades.JSFController#getFullyQualifiedImplementationPath()
193    * @return String
194    */
195    protected abstract String handleGetFullyQualifiedImplementationPath();
196
197    private String __fullyQualifiedImplementationPath3a;
198    private boolean __fullyQualifiedImplementationPath3aSet = false;
199
200    /**
201     * The fully qualified path to the controller implemention file.
202     * @return (String)handleGetFullyQualifiedImplementationPath()
203     */
204    public final String getFullyQualifiedImplementationPath()
205    {
206        String fullyQualifiedImplementationPath3a = this.__fullyQualifiedImplementationPath3a;
207        if (!this.__fullyQualifiedImplementationPath3aSet)
208        {
209            // fullyQualifiedImplementationPath has no pre constraints
210            fullyQualifiedImplementationPath3a = handleGetFullyQualifiedImplementationPath();
211            // fullyQualifiedImplementationPath has no post constraints
212            this.__fullyQualifiedImplementationPath3a = fullyQualifiedImplementationPath3a;
213            if (isMetafacadePropertyCachingEnabled())
214            {
215                this.__fullyQualifiedImplementationPath3aSet = true;
216            }
217        }
218        return fullyQualifiedImplementationPath3a;
219    }
220
221   /**
222    * @see org.andromda.cartridges.jsf2.metafacades.JSFController#getBeanName()
223    * @return String
224    */
225    protected abstract String handleGetBeanName();
226
227    private String __beanName4a;
228    private boolean __beanName4aSet = false;
229
230    /**
231     * The bean name of this controller (this is what is stored in the JSF configuration file).
232     * @return (String)handleGetBeanName()
233     */
234    public final String getBeanName()
235    {
236        String beanName4a = this.__beanName4a;
237        if (!this.__beanName4aSet)
238        {
239            // beanName has no pre constraints
240            beanName4a = handleGetBeanName();
241            // beanName has no post constraints
242            this.__beanName4a = beanName4a;
243            if (isMetafacadePropertyCachingEnabled())
244            {
245                this.__beanName4aSet = true;
246            }
247        }
248        return beanName4a;
249    }
250
251   /**
252    * @see org.andromda.cartridges.jsf2.metafacades.JSFController#getControllerSerialVersionUID()
253    * @return String
254    */
255    protected abstract String handleGetControllerSerialVersionUID();
256
257    private String __controllerSerialVersionUID5a;
258    private boolean __controllerSerialVersionUID5aSet = false;
259
260    /**
261     * The calculated serial version UID for this controller.
262     * @return (String)handleGetControllerSerialVersionUID()
263     */
264    public final String getControllerSerialVersionUID()
265    {
266        String controllerSerialVersionUID5a = this.__controllerSerialVersionUID5a;
267        if (!this.__controllerSerialVersionUID5aSet)
268        {
269            // controllerSerialVersionUID has no pre constraints
270            controllerSerialVersionUID5a = handleGetControllerSerialVersionUID();
271            // controllerSerialVersionUID has no post constraints
272            this.__controllerSerialVersionUID5a = controllerSerialVersionUID5a;
273            if (isMetafacadePropertyCachingEnabled())
274            {
275                this.__controllerSerialVersionUID5aSet = true;
276            }
277        }
278        return controllerSerialVersionUID5a;
279    }
280
281   /**
282    * @see org.andromda.cartridges.jsf2.metafacades.JSFController#getAllServices()
283    * @return Collection
284    */
285    protected abstract Collection handleGetAllServices();
286
287    private Collection __allServices6a;
288    private boolean __allServices6aSet = false;
289
290    /**
291     * All services the controller needs.
292     * @return (Collection)handleGetAllServices()
293     */
294    public final Collection getAllServices()
295    {
296        Collection allServices6a = this.__allServices6a;
297        if (!this.__allServices6aSet)
298        {
299            // allServices has no pre constraints
300            allServices6a = handleGetAllServices();
301            // allServices has no post constraints
302            this.__allServices6a = allServices6a;
303            if (isMetafacadePropertyCachingEnabled())
304            {
305                this.__allServices6aSet = true;
306            }
307        }
308        return allServices6a;
309    }
310
311    // ------------- associations ------------------
312
313    private List<DependencyFacade> __getServicesPackagesReferences1r;
314    private boolean __getServicesPackagesReferences1rSet = false;
315
316    /**
317     * Represents a controller for a JSF application.
318     * @return (List<DependencyFacade>)handleGetServicesPackagesReferences()
319     */
320    public final List<DependencyFacade> getServicesPackagesReferences()
321    {
322        List<DependencyFacade> getServicesPackagesReferences1r = this.__getServicesPackagesReferences1r;
323        if (!this.__getServicesPackagesReferences1rSet)
324        {
325            // jSFController has no pre constraints
326            List result = handleGetServicesPackagesReferences();
327            List shieldedResult = this.shieldedElements(result);
328            try
329            {
330                getServicesPackagesReferences1r = (List<DependencyFacade>)shieldedResult;
331            }
332            catch (ClassCastException ex)
333            {
334                // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
335                JSFControllerLogic.logger.warn("incorrect metafacade cast for JSFControllerLogic.getServicesPackagesReferences List<DependencyFacade> " + result + ": " + shieldedResult);
336            }
337            // jSFController has no post constraints
338            this.__getServicesPackagesReferences1r = getServicesPackagesReferences1r;
339            if (isMetafacadePropertyCachingEnabled())
340            {
341                this.__getServicesPackagesReferences1rSet = true;
342            }
343        }
344        return getServicesPackagesReferences1r;
345    }
346
347    /**
348     * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
349     * @return  List
350     */
351    protected abstract List handleGetServicesPackagesReferences();
352
353    private List<DependencyFacade> __getSessionObjectReferences2r;
354    private boolean __getSessionObjectReferences2rSet = false;
355
356    /**
357     * Represents a controller for a JSF application.
358     * @return (List<DependencyFacade>)handleGetSessionObjectReferences()
359     */
360    public final List<DependencyFacade> getSessionObjectReferences()
361    {
362        List<DependencyFacade> getSessionObjectReferences2r = this.__getSessionObjectReferences2r;
363        if (!this.__getSessionObjectReferences2rSet)
364        {
365            // jSFController has no pre constraints
366            List result = handleGetSessionObjectReferences();
367            List shieldedResult = this.shieldedElements(result);
368            try
369            {
370                getSessionObjectReferences2r = (List<DependencyFacade>)shieldedResult;
371            }
372            catch (ClassCastException ex)
373            {
374                // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
375                JSFControllerLogic.logger.warn("incorrect metafacade cast for JSFControllerLogic.getSessionObjectReferences List<DependencyFacade> " + result + ": " + shieldedResult);
376            }
377            // jSFController has no post constraints
378            this.__getSessionObjectReferences2r = getSessionObjectReferences2r;
379            if (isMetafacadePropertyCachingEnabled())
380            {
381                this.__getSessionObjectReferences2rSet = true;
382            }
383        }
384        return getSessionObjectReferences2r;
385    }
386
387    /**
388     * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
389     * @return  List
390     */
391    protected abstract List handleGetSessionObjectReferences();
392
393    /**
394     * @return true
395     * @see FrontEndController
396     */
397    public boolean isFrontEndControllerMetaType()
398    {
399        return true;
400    }
401
402    /**
403     * @return true
404     * @see ClassifierFacade
405     */
406    public boolean isClassifierFacadeMetaType()
407    {
408        return true;
409    }
410
411    /**
412     * @return true
413     * @see GeneralizableElementFacade
414     */
415    public boolean isGeneralizableElementFacadeMetaType()
416    {
417        return true;
418    }
419
420    /**
421     * @return true
422     * @see ModelElementFacade
423     */
424    public boolean isModelElementFacadeMetaType()
425    {
426        return true;
427    }
428
429    // ----------- delegates to FrontEndController ------------
430    /**
431     * Return the attribute which name matches the parameter
432     * @see ClassifierFacade#findAttribute(String name)
433     */
434    public AttributeFacade findAttribute(String name)
435    {
436        return this.getSuperFrontEndController().findAttribute(name);
437    }
438
439    /**
440     * Those abstraction dependencies for which this classifier is the client.
441     * @see ClassifierFacade#getAbstractions()
442     */
443    public Collection<ClassifierFacade> getAbstractions()
444    {
445        return this.getSuperFrontEndController().getAbstractions();
446    }
447
448    /**
449     * Lists all classes associated to this one and any ancestor classes (through generalization).
450     * There will be no duplicates. The order of the elements is predictable.
451     * @see ClassifierFacade#getAllAssociatedClasses()
452     */
453    public Collection<ClassifierFacade> getAllAssociatedClasses()
454    {
455        return this.getSuperFrontEndController().getAllAssociatedClasses();
456    }
457
458    /**
459     * A collection containing all 'properties' of the classifier and its ancestors.  Properties are
460     * any attributes and navigable connecting association ends.
461     * @see ClassifierFacade#getAllProperties()
462     */
463    public Collection<ModelElementFacade> getAllProperties()
464    {
465        return this.getSuperFrontEndController().getAllProperties();
466    }
467
468    /**
469     * A collection containing all required and/or read-only 'properties' of the classifier and its
470     * ancestors. Properties are any attributes and navigable connecting association ends.
471     * @see ClassifierFacade#getAllRequiredConstructorParameters()
472     */
473    public Collection<ModelElementFacade> getAllRequiredConstructorParameters()
474    {
475        return this.getSuperFrontEndController().getAllRequiredConstructorParameters();
476    }
477
478    /**
479     * Gets the array type for this classifier.  If this classifier already represents an array, it
480     * just returns itself.
481     * @see ClassifierFacade#getArray()
482     */
483    public ClassifierFacade getArray()
484    {
485        return this.getSuperFrontEndController().getArray();
486    }
487
488    /**
489     * The name of the classifier as an array.
490     * @see ClassifierFacade#getArrayName()
491     */
492    public String getArrayName()
493    {
494        return this.getSuperFrontEndController().getArrayName();
495    }
496
497    /**
498     * Lists the classes associated to this one, there is no repitition of classes. The order of the
499     * elements is predictable.
500     * @see ClassifierFacade#getAssociatedClasses()
501     */
502    public Collection<ClassifierFacade> getAssociatedClasses()
503    {
504        return this.getSuperFrontEndController().getAssociatedClasses();
505    }
506
507    /**
508     * Gets the association ends belonging to a classifier.
509     * @see ClassifierFacade#getAssociationEnds()
510     */
511    public List<AssociationEndFacade> getAssociationEnds()
512    {
513        return this.getSuperFrontEndController().getAssociationEnds();
514    }
515
516    /**
517     * Gets the attributes that belong to the classifier.
518     * @see ClassifierFacade#getAttributes()
519     */
520    public List<AttributeFacade> getAttributes()
521    {
522        return this.getSuperFrontEndController().getAttributes();
523    }
524
525    /**
526     * Gets all attributes for the classifier and if 'follow' is true goes up the inheritance
527     * hierarchy and gets the attributes from the super classes as well.
528     * @see ClassifierFacade#getAttributes(boolean follow)
529     */
530    public List<AttributeFacade> getAttributes(boolean follow)
531    {
532        return this.getSuperFrontEndController().getAttributes(follow);
533    }
534
535    /**
536     * The fully qualified name of the classifier as an array.
537     * @see ClassifierFacade#getFullyQualifiedArrayName()
538     */
539    public String getFullyQualifiedArrayName()
540    {
541        return this.getSuperFrontEndController().getFullyQualifiedArrayName();
542    }
543
544    /**
545     * Returns all those operations that could be implemented at this classifier's level. This means
546     * the operations owned by this classifier as well as any realized interface's operations
547     * (recursively) in case this classifier itself is not already an interface, or generalized when
548     * this classifier is an interface.
549     * @see ClassifierFacade#getImplementationOperations()
550     */
551    public Collection<OperationFacade> getImplementationOperations()
552    {
553        return this.getSuperFrontEndController().getImplementationOperations();
554    }
555
556    /**
557     * A comma separated list of the fully qualified names of all implemented interfaces.
558     * @see ClassifierFacade#getImplementedInterfaceList()
559     */
560    public String getImplementedInterfaceList()
561    {
562        return this.getSuperFrontEndController().getImplementedInterfaceList();
563    }
564
565    /**
566     * Those attributes that are scoped to an instance of this class.
567     * @see ClassifierFacade#getInstanceAttributes()
568     */
569    public Collection<AttributeFacade> getInstanceAttributes()
570    {
571        return this.getSuperFrontEndController().getInstanceAttributes();
572    }
573
574    /**
575     * Those operations that are scoped to an instance of this class.
576     * @see ClassifierFacade#getInstanceOperations()
577     */
578    public List<OperationFacade> getInstanceOperations()
579    {
580        return this.getSuperFrontEndController().getInstanceOperations();
581    }
582
583    /**
584     * Those interfaces that are abstractions of this classifier, this basically means this
585     * classifier realizes them.
586     * @see ClassifierFacade#getInterfaceAbstractions()
587     */
588    public Collection<ClassifierFacade> getInterfaceAbstractions()
589    {
590        return this.getSuperFrontEndController().getInterfaceAbstractions();
591    }
592
593    /**
594     * A String representing a new Constructor declaration for this classifier type to be used in a
595     * Java environment.
596     * @see ClassifierFacade#getJavaNewString()
597     */
598    public String getJavaNewString()
599    {
600        return this.getSuperFrontEndController().getJavaNewString();
601    }
602
603    /**
604     * A String representing the null-value for this classifier type to be used in a Java
605     * environment.
606     * @see ClassifierFacade#getJavaNullString()
607     */
608    public String getJavaNullString()
609    {
610        return this.getSuperFrontEndController().getJavaNullString();
611    }
612
613    /**
614     * The other ends of this classifier's association ends which are navigable.
615     * @see ClassifierFacade#getNavigableConnectingEnds()
616     */
617    public Collection<AssociationEndFacade> getNavigableConnectingEnds()
618    {
619        return this.getSuperFrontEndController().getNavigableConnectingEnds();
620    }
621
622    /**
623     * Get the other ends of this classifier's association ends which are navigable and if 'follow'
624     * is true goes up the inheritance hierarchy and gets the super association ends as well.
625     * @see ClassifierFacade#getNavigableConnectingEnds(boolean follow)
626     */
627    public List<AssociationEndFacade> getNavigableConnectingEnds(boolean follow)
628    {
629        return this.getSuperFrontEndController().getNavigableConnectingEnds(follow);
630    }
631
632    /**
633     * Assuming that the classifier is an array, this will return the non array type of the
634     * classifier from
635     * the model.  If the classifier is NOT an array, it will just return itself.
636     * @see ClassifierFacade#getNonArray()
637     */
638    public ClassifierFacade getNonArray()
639    {
640        return this.getSuperFrontEndController().getNonArray();
641    }
642
643    /**
644     * The attributes from this classifier in the form of an operation call (this example would be
645     * in Java): '(String attributeOne, String attributeTwo).  If there were no attributes on the
646     * classifier, the result would be an empty '()'.
647     * @see ClassifierFacade#getOperationCallFromAttributes()
648     */
649    public String getOperationCallFromAttributes()
650    {
651        return this.getSuperFrontEndController().getOperationCallFromAttributes();
652    }
653
654    /**
655     * The operations owned by this classifier.
656     * @see ClassifierFacade#getOperations()
657     */
658    public List<OperationFacade> getOperations()
659    {
660        return this.getSuperFrontEndController().getOperations();
661    }
662
663    /**
664     * A collection containing all 'properties' of the classifier.  Properties are any attributes
665     * and navigable connecting association ends.
666     * @see ClassifierFacade#getProperties()
667     */
668    public List<ModelElementFacade> getProperties()
669    {
670        return this.getSuperFrontEndController().getProperties();
671    }
672
673    /**
674     * Gets all properties (attributes and navigable association ends) for the classifier and if
675     * 'follow' is true goes up the inheritance hierarchy and gets the properties from the super
676     * classes as well.
677     * @see ClassifierFacade#getProperties(boolean follow)
678     */
679    public List getProperties(boolean follow)
680    {
681        return this.getSuperFrontEndController().getProperties(follow);
682    }
683
684    /**
685     * A collection containing all required and/or read-only 'properties' of the classifier. 
686     * Properties are any attributes and navigable connecting association ends.
687     * @see ClassifierFacade#getRequiredConstructorParameters()
688     */
689    public Collection<ModelElementFacade> getRequiredConstructorParameters()
690    {
691        return this.getSuperFrontEndController().getRequiredConstructorParameters();
692    }
693
694    /**
695     * Returns the serial version UID of the underlying model element.
696     * @see ClassifierFacade#getSerialVersionUID()
697     */
698    public long getSerialVersionUID()
699    {
700        return this.getSuperFrontEndController().getSerialVersionUID();
701    }
702
703    /**
704     * Those attributes that are scoped to the definition of this class.
705     * @see ClassifierFacade#getStaticAttributes()
706     */
707    public Collection<AttributeFacade> getStaticAttributes()
708    {
709        return this.getSuperFrontEndController().getStaticAttributes();
710    }
711
712    /**
713     * Those operations that are scoped to the definition of this class.
714     * @see ClassifierFacade#getStaticOperations()
715     */
716    public List<OperationFacade> getStaticOperations()
717    {
718        return this.getSuperFrontEndController().getStaticOperations();
719    }
720
721    /**
722     * This class' superclass, returns the generalization if it is a ClassifierFacade, null
723     * otherwise.
724     * @see ClassifierFacade#getSuperClass()
725     */
726    public ClassifierFacade getSuperClass()
727    {
728        return this.getSuperFrontEndController().getSuperClass();
729    }
730
731    /**
732     * The wrapper name for this classifier if a mapped type has a defined wrapper class (ie. 'long'
733     * maps to 'Long').  If the classifier doesn't have a wrapper defined for it, this method will
734     * return a null.  Note that wrapper mappings must be defined for the namespace by defining the
735     * 'wrapperMappingsUri', this property must point to the location of the mappings file which
736     * maps the primitives to wrapper types.
737     * @see ClassifierFacade#getWrapperName()
738     */
739    public String getWrapperName()
740    {
741        return this.getSuperFrontEndController().getWrapperName();
742    }
743
744    /**
745     * Indicates if this classifier is 'abstract'.
746     * @see ClassifierFacade#isAbstract()
747     */
748    public boolean isAbstract()
749    {
750        return this.getSuperFrontEndController().isAbstract();
751    }
752
753    /**
754     * True if this classifier represents an array type. False otherwise.
755     * @see ClassifierFacade#isArrayType()
756     */
757    public boolean isArrayType()
758    {
759        return this.getSuperFrontEndController().isArrayType();
760    }
761
762    /**
763     * True if the ClassifierFacade is an AssociationClass.
764     * @see ClassifierFacade#isAssociationClass()
765     */
766    public boolean isAssociationClass()
767    {
768        return this.getSuperFrontEndController().isAssociationClass();
769    }
770
771    /**
772     * Returns true if this type represents a Blob type.
773     * @see ClassifierFacade#isBlobType()
774     */
775    public boolean isBlobType()
776    {
777        return this.getSuperFrontEndController().isBlobType();
778    }
779
780    /**
781     * Indicates if this type represents a boolean type or not.
782     * @see ClassifierFacade#isBooleanType()
783     */
784    public boolean isBooleanType()
785    {
786        return this.getSuperFrontEndController().isBooleanType();
787    }
788
789    /**
790     * Indicates if this type represents a char, Character, or java.lang.Character type or not.
791     * @see ClassifierFacade#isCharacterType()
792     */
793    public boolean isCharacterType()
794    {
795        return this.getSuperFrontEndController().isCharacterType();
796    }
797
798    /**
799     * Returns true if this type represents a Clob type.
800     * @see ClassifierFacade#isClobType()
801     */
802    public boolean isClobType()
803    {
804        return this.getSuperFrontEndController().isClobType();
805    }
806
807    /**
808     * True if this classifier represents a collection type. False otherwise.
809     * @see ClassifierFacade#isCollectionType()
810     */
811    public boolean isCollectionType()
812    {
813        return this.getSuperFrontEndController().isCollectionType();
814    }
815
816    /**
817     * True/false depending on whether or not this classifier represents a datatype. A data type is
818     * a type whose instances are identified only by their value. A data type may contain attributes
819     * to support the modeling of structured data types.
820     * @see ClassifierFacade#isDataType()
821     */
822    public boolean isDataType()
823    {
824        return this.getSuperFrontEndController().isDataType();
825    }
826
827    /**
828     * True when this classifier is a date type.
829     * @see ClassifierFacade#isDateType()
830     */
831    public boolean isDateType()
832    {
833        return this.getSuperFrontEndController().isDateType();
834    }
835
836    /**
837     * Indicates if this type represents a Double type or not.
838     * @see ClassifierFacade#isDoubleType()
839     */
840    public boolean isDoubleType()
841    {
842        return this.getSuperFrontEndController().isDoubleType();
843    }
844
845    /**
846     * Indicates whether or not this classifier represents an "EmbeddedValue'.
847     * @see ClassifierFacade#isEmbeddedValue()
848     */
849    public boolean isEmbeddedValue()
850    {
851        return this.getSuperFrontEndController().isEmbeddedValue();
852    }
853
854    /**
855     * True if this classifier is in fact marked as an enumeration.
856     * @see ClassifierFacade#isEnumeration()
857     */
858    public boolean isEnumeration()
859    {
860        return this.getSuperFrontEndController().isEnumeration();
861    }
862
863    /**
864     * Returns true if this type represents a 'file' type.
865     * @see ClassifierFacade#isFileType()
866     */
867    public boolean isFileType()
868    {
869        return this.getSuperFrontEndController().isFileType();
870    }
871
872    /**
873     * Indicates if this type represents a Float type or not.
874     * @see ClassifierFacade#isFloatType()
875     */
876    public boolean isFloatType()
877    {
878        return this.getSuperFrontEndController().isFloatType();
879    }
880
881    /**
882     * Indicates if this type represents an int or Integer or java.lang.Integer type or not.
883     * @see ClassifierFacade#isIntegerType()
884     */
885    public boolean isIntegerType()
886    {
887        return this.getSuperFrontEndController().isIntegerType();
888    }
889
890    /**
891     * True/false depending on whether or not this Classifier represents an interface.
892     * @see ClassifierFacade#isInterface()
893     */
894    public boolean isInterface()
895    {
896        return this.getSuperFrontEndController().isInterface();
897    }
898
899    /**
900     * True if this classifier cannot be extended and represent a leaf in the inheritance tree.
901     * @see ClassifierFacade#isLeaf()
902     */
903    public boolean isLeaf()
904    {
905        return this.getSuperFrontEndController().isLeaf();
906    }
907
908    /**
909     * True if this classifier represents a list type. False otherwise.
910     * @see ClassifierFacade#isListType()
911     */
912    public boolean isListType()
913    {
914        return this.getSuperFrontEndController().isListType();
915    }
916
917    /**
918     * Indicates if this type represents a Long type or not.
919     * @see ClassifierFacade#isLongType()
920     */
921    public boolean isLongType()
922    {
923        return this.getSuperFrontEndController().isLongType();
924    }
925
926    /**
927     * Indicates whether or not this classifier represents a Map type.
928     * @see ClassifierFacade#isMapType()
929     */
930    public boolean isMapType()
931    {
932        return this.getSuperFrontEndController().isMapType();
933    }
934
935    /**
936     * Indicates whether or not this classifier represents a primitive type.
937     * @see ClassifierFacade#isPrimitive()
938     */
939    public boolean isPrimitive()
940    {
941        return this.getSuperFrontEndController().isPrimitive();
942    }
943
944    /**
945     * True if this classifier represents a set type. False otherwise.
946     * @see ClassifierFacade#isSetType()
947     */
948    public boolean isSetType()
949    {
950        return this.getSuperFrontEndController().isSetType();
951    }
952
953    /**
954     * Indicates whether or not this classifier represents a string type.
955     * @see ClassifierFacade#isStringType()
956     */
957    public boolean isStringType()
958    {
959        return this.getSuperFrontEndController().isStringType();
960    }
961
962    /**
963     * Indicates whether or not this classifier represents a time type.
964     * @see ClassifierFacade#isTimeType()
965     */
966    public boolean isTimeType()
967    {
968        return this.getSuperFrontEndController().isTimeType();
969    }
970
971    /**
972     * Returns true if this type is a wrapped primitive type.
973     * @see ClassifierFacade#isWrappedPrimitive()
974     */
975    public boolean isWrappedPrimitive()
976    {
977        return this.getSuperFrontEndController().isWrappedPrimitive();
978    }
979
980    /**
981     * All actions that defer to at least one operation of this controller.
982     * @see FrontEndController#getDeferringActions()
983     */
984    public List<FrontEndAction> getDeferringActions()
985    {
986        return this.getSuperFrontEndController().getDeferringActions();
987    }
988
989    /**
990     * Returns all back-end services referenced by this controller.
991     * @see FrontEndController#getServiceReferences()
992     */
993    public List<DependencyFacade> getServiceReferences()
994    {
995        return this.getSuperFrontEndController().getServiceReferences();
996    }
997
998    /**
999     * Returns the use-case "controlled" by this controller.
1000     * @see FrontEndController#getUseCase()
1001     */
1002    public FrontEndUseCase getUseCase()
1003    {
1004        return this.getSuperFrontEndController().getUseCase();
1005    }
1006
1007    /**
1008     * Finds the tagged value optional searching the entire inheritance hierarchy if 'follow' is set
1009     * to true.
1010     * @see GeneralizableElementFacade#findTaggedValue(String tagName, boolean follow)
1011     */
1012    public Object findTaggedValue(String tagName, boolean follow)
1013    {
1014        return this.getSuperFrontEndController().findTaggedValue(tagName, follow);
1015    }
1016
1017    /**
1018     * All generalizations for this generalizable element, goes up the inheritance tree.
1019     * @see GeneralizableElementFacade#getAllGeneralizations()
1020     */
1021    public Collection<GeneralizableElementFacade> getAllGeneralizations()
1022    {
1023        return this.getSuperFrontEndController().getAllGeneralizations();
1024    }
1025
1026    /**
1027     * All specializations (travels down the inheritance hierarchy).
1028     * @see GeneralizableElementFacade#getAllSpecializations()
1029     */
1030    public Collection<GeneralizableElementFacade> getAllSpecializations()
1031    {
1032        return this.getSuperFrontEndController().getAllSpecializations();
1033    }
1034
1035    /**
1036     * Gets the direct generalization for this generalizable element.
1037     * @see GeneralizableElementFacade#getGeneralization()
1038     */
1039    public GeneralizableElementFacade getGeneralization()
1040    {
1041        return this.getSuperFrontEndController().getGeneralization();
1042    }
1043
1044    /**
1045     * Gets the actual links that this generalization element is part of (it plays either the
1046     * specialization or generalization).
1047     * @see GeneralizableElementFacade#getGeneralizationLinks()
1048     */
1049    public Collection<GeneralizationFacade> getGeneralizationLinks()
1050    {
1051        return this.getSuperFrontEndController().getGeneralizationLinks();
1052    }
1053
1054    /**
1055     * A comma separated list of the fully qualified names of all generalizations.
1056     * @see GeneralizableElementFacade#getGeneralizationList()
1057     */
1058    public String getGeneralizationList()
1059    {
1060        return this.getSuperFrontEndController().getGeneralizationList();
1061    }
1062
1063    /**
1064     * The element found when you recursively follow the generalization path up to the root. If an
1065     * element has no generalization itself will be considered the root.
1066     * @see GeneralizableElementFacade#getGeneralizationRoot()
1067     */
1068    public GeneralizableElementFacade getGeneralizationRoot()
1069    {
1070        return this.getSuperFrontEndController().getGeneralizationRoot();
1071    }
1072
1073    /**
1074     * Return all generalizations (ancestors) from this generalizable element.
1075     * @see GeneralizableElementFacade#getGeneralizations()
1076     */
1077    public Collection<GeneralizableElementFacade> getGeneralizations()
1078    {
1079        return this.getSuperFrontEndController().getGeneralizations();
1080    }
1081
1082    /**
1083     * Gets the direct specializations (i.e. sub elements) for this generalizatble element.
1084     * @see GeneralizableElementFacade#getSpecializations()
1085     */
1086    public Collection<GeneralizableElementFacade> getSpecializations()
1087    {
1088        return this.getSuperFrontEndController().getSpecializations();
1089    }
1090
1091    /**
1092     * Copies all tagged values from the given ModelElementFacade to this model element facade.
1093     * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element)
1094     */
1095    public void copyTaggedValues(ModelElementFacade element)
1096    {
1097        this.getSuperFrontEndController().copyTaggedValues(element);
1098    }
1099
1100    /**
1101     * Finds the tagged value with the specified 'tagName'. In case there are more values the first
1102     * one found will be returned.
1103     * @see ModelElementFacade#findTaggedValue(String tagName)
1104     */
1105    public Object findTaggedValue(String tagName)
1106    {
1107        return this.getSuperFrontEndController().findTaggedValue(tagName);
1108    }
1109
1110    /**
1111     * Returns all the values for the tagged value with the specified name. The returned collection
1112     * will contains only String instances, or will be empty. Never null.
1113     * @see ModelElementFacade#findTaggedValues(String tagName)
1114     */
1115    public Collection<Object> findTaggedValues(String tagName)
1116    {
1117        return this.getSuperFrontEndController().findTaggedValues(tagName);
1118    }
1119
1120    /**
1121     * Returns the fully qualified name of the model element. The fully qualified name includes
1122     * complete package qualified name of the underlying model element. The templates parameter will
1123     * be replaced by the correct one given the binding relation of the parameter to this element.
1124     * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement)
1125     */
1126    public String getBindedFullyQualifiedName(ModelElementFacade bindedElement)
1127    {
1128        return this.getSuperFrontEndController().getBindedFullyQualifiedName(bindedElement);
1129    }
1130
1131    /**
1132     * Gets all constraints belonging to the model element.
1133     * @see ModelElementFacade#getConstraints()
1134     */
1135    public Collection<ConstraintFacade> getConstraints()
1136    {
1137        return this.getSuperFrontEndController().getConstraints();
1138    }
1139
1140    /**
1141     * Returns the constraints of the argument kind that have been placed onto this model. Typical
1142     * kinds are "inv", "pre" and "post". Other kinds are possible.
1143     * @see ModelElementFacade#getConstraints(String kind)
1144     */
1145    public Collection<ConstraintFacade> getConstraints(String kind)
1146    {
1147        return this.getSuperFrontEndController().getConstraints(kind);
1148    }
1149
1150    /**
1151     * Gets the documentation for the model element, The indent argument is prefixed to each line.
1152     * By default this method wraps lines after 64 characters.
1153     * This method is equivalent to <code>getDocumentation(indent, 64)</code>.
1154     * @see ModelElementFacade#getDocumentation(String indent)
1155     */
1156    public String getDocumentation(String indent)
1157    {
1158        return this.getSuperFrontEndController().getDocumentation(indent);
1159    }
1160
1161    /**
1162     * This method returns the documentation for this model element, with the lines wrapped after
1163     * the specified number of characters, values of less than 1 will indicate no line wrapping is
1164     * required. By default paragraphs are returned as HTML.
1165     * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>.
1166     * @see ModelElementFacade#getDocumentation(String indent, int lineLength)
1167     */
1168    public String getDocumentation(String indent, int lineLength)
1169    {
1170        return this.getSuperFrontEndController().getDocumentation(indent, lineLength);
1171    }
1172
1173    /**
1174     * This method returns the documentation for this model element, with the lines wrapped after
1175     * the specified number of characters, values of less than 1 will indicate no line wrapping is
1176     * required. HTML style determines if HTML Escaping is applied.
1177     * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle)
1178     */
1179    public String getDocumentation(String indent, int lineLength, boolean htmlStyle)
1180    {
1181        return this.getSuperFrontEndController().getDocumentation(indent, lineLength, htmlStyle);
1182    }
1183
1184    /**
1185     * The fully qualified name of this model element.
1186     * @see ModelElementFacade#getFullyQualifiedName()
1187     */
1188    public String getFullyQualifiedName()
1189    {
1190        return this.getSuperFrontEndController().getFullyQualifiedName();
1191    }
1192
1193    /**
1194     * Returns the fully qualified name of the model element. The fully qualified name includes
1195     * complete package qualified name of the underlying model element.  If modelName is true, then
1196     * the original name of the model element (the name contained within the model) will be the name
1197     * returned, otherwise a name from a language mapping will be returned.
1198     * @see ModelElementFacade#getFullyQualifiedName(boolean modelName)
1199     */
1200    public String getFullyQualifiedName(boolean modelName)
1201    {
1202        return this.getSuperFrontEndController().getFullyQualifiedName(modelName);
1203    }
1204
1205    /**
1206     * Returns the fully qualified name as a path, the returned value always starts with out a slash
1207     * '/'.
1208     * @see ModelElementFacade#getFullyQualifiedNamePath()
1209     */
1210    public String getFullyQualifiedNamePath()
1211    {
1212        return this.getSuperFrontEndController().getFullyQualifiedNamePath();
1213    }
1214
1215    /**
1216     * Gets the unique identifier of the underlying model element.
1217     * @see ModelElementFacade#getId()
1218     */
1219    public String getId()
1220    {
1221        return this.getSuperFrontEndController().getId();
1222    }
1223
1224    /**
1225     * UML2: Retrieves the keywords for this element. Used to modify implementation properties which
1226     * are not represented by other properties, i.e. native, transient, volatile, synchronized,
1227     * (added annotations) override, deprecated. Can also be used to suppress compiler warnings:
1228     * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require
1229     * JDK5 compiler level.
1230     * @see ModelElementFacade#getKeywords()
1231     */
1232    public Collection<String> getKeywords()
1233    {
1234        return this.getSuperFrontEndController().getKeywords();
1235    }
1236
1237    /**
1238     * UML2: Retrieves a localized label for this named element.
1239     * @see ModelElementFacade#getLabel()
1240     */
1241    public String getLabel()
1242    {
1243        return this.getSuperFrontEndController().getLabel();
1244    }
1245
1246    /**
1247     * The language mappings that have been set for this model element.
1248     * @see ModelElementFacade#getLanguageMappings()
1249     */
1250    public TypeMappings getLanguageMappings()
1251    {
1252        return this.getSuperFrontEndController().getLanguageMappings();
1253    }
1254
1255    /**
1256     * Return the model containing this model element (multiple models may be loaded and processed
1257     * at the same time).
1258     * @see ModelElementFacade#getModel()
1259     */
1260    public ModelFacade getModel()
1261    {
1262        return this.getSuperFrontEndController().getModel();
1263    }
1264
1265    /**
1266     * The name of the model element.
1267     * @see ModelElementFacade#getName()
1268     */
1269    public String getName()
1270    {
1271        return this.getSuperFrontEndController().getName();
1272    }
1273
1274    /**
1275     * Gets the package to which this model element belongs.
1276     * @see ModelElementFacade#getPackage()
1277     */
1278    public ModelElementFacade getPackage()
1279    {
1280        return this.getSuperFrontEndController().getPackage();
1281    }
1282
1283    /**
1284     * The name of this model element's package.
1285     * @see ModelElementFacade#getPackageName()
1286     */
1287    public String getPackageName()
1288    {
1289        return this.getSuperFrontEndController().getPackageName();
1290    }
1291
1292    /**
1293     * Gets the package name (optionally providing the ability to retrieve the model name and not
1294     * the mapped name).
1295     * @see ModelElementFacade#getPackageName(boolean modelName)
1296     */
1297    public String getPackageName(boolean modelName)
1298    {
1299        return this.getSuperFrontEndController().getPackageName(modelName);
1300    }
1301
1302    /**
1303     * Returns the package as a path, the returned value always starts with out a slash '/'.
1304     * @see ModelElementFacade#getPackagePath()
1305     */
1306    public String getPackagePath()
1307    {
1308        return this.getSuperFrontEndController().getPackagePath();
1309    }
1310
1311    /**
1312     * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the
1313     * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from
1314     * the names of the containing namespaces starting at the root of the hierarchy and ending with
1315     * the name of the NamedElement itself.
1316     * @see ModelElementFacade#getQualifiedName()
1317     */
1318    public String getQualifiedName()
1319    {
1320        return this.getSuperFrontEndController().getQualifiedName();
1321    }
1322
1323    /**
1324     * Gets the root package for the model element.
1325     * @see ModelElementFacade#getRootPackage()
1326     */
1327    public PackageFacade getRootPackage()
1328    {
1329        return this.getSuperFrontEndController().getRootPackage();
1330    }
1331
1332    /**
1333     * Gets the dependencies for which this model element is the source.
1334     * @see ModelElementFacade#getSourceDependencies()
1335     */
1336    public Collection<DependencyFacade> getSourceDependencies()
1337    {
1338        return this.getSuperFrontEndController().getSourceDependencies();
1339    }
1340
1341    /**
1342     * If this model element is the context of an activity graph, this represents that activity
1343     * graph.
1344     * @see ModelElementFacade#getStateMachineContext()
1345     */
1346    public StateMachineFacade getStateMachineContext()
1347    {
1348        return this.getSuperFrontEndController().getStateMachineContext();
1349    }
1350
1351    /**
1352     * The collection of ALL stereotype names for this model element.
1353     * @see ModelElementFacade#getStereotypeNames()
1354     */
1355    public Collection<String> getStereotypeNames()
1356    {
1357        return this.getSuperFrontEndController().getStereotypeNames();
1358    }
1359
1360    /**
1361     * Gets all stereotypes for this model element.
1362     * @see ModelElementFacade#getStereotypes()
1363     */
1364    public Collection<StereotypeFacade> getStereotypes()
1365    {
1366        return this.getSuperFrontEndController().getStereotypes();
1367    }
1368
1369    /**
1370     * Return the TaggedValues associated with this model element, under all stereotypes.
1371     * @see ModelElementFacade#getTaggedValues()
1372     */
1373    public Collection<TaggedValueFacade> getTaggedValues()
1374    {
1375        return this.getSuperFrontEndController().getTaggedValues();
1376    }
1377
1378    /**
1379     * Gets the dependencies for which this model element is the target.
1380     * @see ModelElementFacade#getTargetDependencies()
1381     */
1382    public Collection<DependencyFacade> getTargetDependencies()
1383    {
1384        return this.getSuperFrontEndController().getTargetDependencies();
1385    }
1386
1387    /**
1388     * Get the template parameter for this model element having the parameterName
1389     * @see ModelElementFacade#getTemplateParameter(String parameterName)
1390     */
1391    public Object getTemplateParameter(String parameterName)
1392    {
1393        return this.getSuperFrontEndController().getTemplateParameter(parameterName);
1394    }
1395
1396    /**
1397     * Get the template parameters for this model element
1398     * @see ModelElementFacade#getTemplateParameters()
1399     */
1400    public Collection<TemplateParameterFacade> getTemplateParameters()
1401    {
1402        return this.getSuperFrontEndController().getTemplateParameters();
1403    }
1404
1405    /**
1406     * The visibility (i.e. public, private, protected or package) of the model element, will
1407     * attempt a lookup for these values in the language mappings (if any).
1408     * @see ModelElementFacade#getVisibility()
1409     */
1410    public String getVisibility()
1411    {
1412        return this.getSuperFrontEndController().getVisibility();
1413    }
1414
1415    /**
1416     * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance
1417     * is taken into account when searching for the stereotype), false otherwise.
1418     * @see ModelElementFacade#hasExactStereotype(String stereotypeName)
1419     */
1420    public boolean hasExactStereotype(String stereotypeName)
1421    {
1422        return this.getSuperFrontEndController().hasExactStereotype(stereotypeName);
1423    }
1424
1425    /**
1426     * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma,
1427     * pipe, semicolon, or << >>
1428     * @see ModelElementFacade#hasKeyword(String keywordName)
1429     */
1430    public boolean hasKeyword(String keywordName)
1431    {
1432        return this.getSuperFrontEndController().hasKeyword(keywordName);
1433    }
1434
1435    /**
1436     * Returns true if the model element has the specified stereotype.  If the stereotype itself
1437     * does not match, then a search will be made up the stereotype inheritance hierarchy, and if
1438     * one of the stereotype's ancestors has a matching name this method will return true, false
1439     * otherwise.
1440     * For example, if we have a certain stereotype called <<exception>> and a model element has a
1441     * stereotype called <<applicationException>> which extends <<exception>>, when calling this
1442     * method with 'stereotypeName' defined as 'exception' the method would return true since
1443     * <<applicationException>> inherits from <<exception>>.  If you want to check if the model
1444     * element has the exact stereotype, then use the method 'hasExactStereotype' instead.
1445     * @see ModelElementFacade#hasStereotype(String stereotypeName)
1446     */
1447    public boolean hasStereotype(String stereotypeName)
1448    {
1449        return this.getSuperFrontEndController().hasStereotype(stereotypeName);
1450    }
1451
1452    /**
1453     * True if there are target dependencies from this element that are instances of BindingFacade.
1454     * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies.
1455     * @see ModelElementFacade#isBindingDependenciesPresent()
1456     */
1457    public boolean isBindingDependenciesPresent()
1458    {
1459        return this.getSuperFrontEndController().isBindingDependenciesPresent();
1460    }
1461
1462    /**
1463     * Indicates if any constraints are present on this model element.
1464     * @see ModelElementFacade#isConstraintsPresent()
1465     */
1466    public boolean isConstraintsPresent()
1467    {
1468        return this.getSuperFrontEndController().isConstraintsPresent();
1469    }
1470
1471    /**
1472     * Indicates if any documentation is present on this model element.
1473     * @see ModelElementFacade#isDocumentationPresent()
1474     */
1475    public boolean isDocumentationPresent()
1476    {
1477        return this.getSuperFrontEndController().isDocumentationPresent();
1478    }
1479
1480    /**
1481     * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript.
1482     * @see ModelElementFacade#isReservedWord()
1483     */
1484    public boolean isReservedWord()
1485    {
1486        return this.getSuperFrontEndController().isReservedWord();
1487    }
1488
1489    /**
1490     * True is there are template parameters on this model element. For UML2, applies to Class,
1491     * Operation, Property, and Parameter.
1492     * @see ModelElementFacade#isTemplateParametersPresent()
1493     */
1494    public boolean isTemplateParametersPresent()
1495    {
1496        return this.getSuperFrontEndController().isTemplateParametersPresent();
1497    }
1498
1499    /**
1500     * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++,
1501     * JavaScript. Contains no spaces, special characters etc. Constraint always applied on
1502     * Enumerations and Interfaces, optionally applies on other model elements.
1503     * @see ModelElementFacade#isValidIdentifierName()
1504     */
1505    public boolean isValidIdentifierName()
1506    {
1507        return this.getSuperFrontEndController().isValidIdentifierName();
1508    }
1509
1510    /**
1511     * Searches for the constraint with the specified 'name' on this model element, and if found
1512     * translates it using the specified 'translation' from a translation library discovered by the
1513     * framework.
1514     * @see ModelElementFacade#translateConstraint(String name, String translation)
1515     */
1516    public String translateConstraint(String name, String translation)
1517    {
1518        return this.getSuperFrontEndController().translateConstraint(name, translation);
1519    }
1520
1521    /**
1522     * Translates all constraints belonging to this model element with the given 'translation'.
1523     * @see ModelElementFacade#translateConstraints(String translation)
1524     */
1525    public String[] translateConstraints(String translation)
1526    {
1527        return this.getSuperFrontEndController().translateConstraints(translation);
1528    }
1529
1530    /**
1531     * Translates the constraints of the specified 'kind' belonging to this model element.
1532     * @see ModelElementFacade#translateConstraints(String kind, String translation)
1533     */
1534    public String[] translateConstraints(String kind, String translation)
1535    {
1536        return this.getSuperFrontEndController().translateConstraints(kind, translation);
1537    }
1538
1539    /**
1540     * @see org.andromda.core.metafacade.MetafacadeBase#initialize()
1541     */
1542    @Override
1543    public void initialize()
1544    {
1545        this.getSuperFrontEndController().initialize();
1546    }
1547
1548    /**
1549     * @return Object getSuperFrontEndController().getValidationOwner()
1550     * @see org.andromda.core.metafacade.MetafacadeBase#getValidationOwner()
1551     */
1552    @Override
1553    public Object getValidationOwner()
1554    {
1555        Object owner = this.getSuperFrontEndController().getValidationOwner();
1556        return owner;
1557    }
1558
1559    /**
1560     * @return String getSuperFrontEndController().getValidationName()
1561     * @see org.andromda.core.metafacade.MetafacadeBase#getValidationName()
1562     */
1563    @Override
1564    public String getValidationName()
1565    {
1566        String name = this.getSuperFrontEndController().getValidationName();
1567        return name;
1568    }
1569
1570    /**
1571     * @param validationMessages Collection<ModelValidationMessage>
1572     * @see org.andromda.core.metafacade.MetafacadeBase#validateInvariants(Collection validationMessages)
1573     */
1574    @Override
1575    public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
1576    {
1577        this.getSuperFrontEndController().validateInvariants(validationMessages);
1578    }
1579
1580    /**
1581     * The property that stores the name of the metafacade.
1582     */
1583    private static final String NAME_PROPERTY = "name";
1584    private static final String FQNAME_PROPERTY = "fullyQualifiedName";
1585
1586    /**
1587     * @see Object#toString()
1588     */
1589    @Override
1590    public String toString()
1591    {
1592        final StringBuilder toString = new StringBuilder(this.getClass().getName());
1593        toString.append("[");
1594        try
1595        {
1596            toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY));
1597        }
1598        catch (final Throwable tryAgain)
1599        {
1600            try
1601            {
1602                toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY));
1603            }
1604            catch (final Throwable ignore)
1605            {
1606                // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property
1607            }
1608        }
1609        toString.append("]");
1610        return toString.toString();
1611    }
1612}