Source code

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