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