View Javadoc
1   // license-header java merge-point
2   //
3   // Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
4   //
5   package org.andromda.cartridges.hibernate.metafacades;
6   
7   import java.util.Collection;
8   import java.util.List;
9   import org.andromda.core.common.Introspector;
10  import org.andromda.core.metafacade.MetafacadeBase;
11  import org.andromda.core.metafacade.MetafacadeFactory;
12  import org.andromda.core.metafacade.ModelValidationMessage;
13  import org.andromda.metafacades.uml.AssociationEndFacade;
14  import org.andromda.metafacades.uml.AttributeFacade;
15  import org.andromda.metafacades.uml.ClassifierFacade;
16  import org.andromda.metafacades.uml.ConstraintFacade;
17  import org.andromda.metafacades.uml.DependencyFacade;
18  import org.andromda.metafacades.uml.EnumerationFacade;
19  import org.andromda.metafacades.uml.GeneralizableElementFacade;
20  import org.andromda.metafacades.uml.GeneralizationFacade;
21  import org.andromda.metafacades.uml.ModelElementFacade;
22  import org.andromda.metafacades.uml.ModelFacade;
23  import org.andromda.metafacades.uml.OperationFacade;
24  import org.andromda.metafacades.uml.PackageFacade;
25  import org.andromda.metafacades.uml.StateMachineFacade;
26  import org.andromda.metafacades.uml.StereotypeFacade;
27  import org.andromda.metafacades.uml.TaggedValueFacade;
28  import org.andromda.metafacades.uml.TemplateParameterFacade;
29  import org.andromda.metafacades.uml.TypeMappings;
30  
31  /**
32   * TODO: Model Documentation for org.andromda.cartridges.hibernate.metafacades.HibernateEnumeration
33   * MetafacadeLogic for HibernateEnumeration
34   *
35   * @see HibernateEnumeration
36   */
37  public abstract class HibernateEnumerationLogic
38      extends MetafacadeBase
39      implements HibernateEnumeration
40  {
41      /**
42       * The underlying UML object
43       * @see Object
44       */
45      protected Object metaObject;
46  
47      /** Create Metafacade implementation instance using the MetafacadeFactory from the context
48       * @param metaObjectIn
49       * @param context
50       */
51      protected HibernateEnumerationLogic(Object metaObjectIn, String context)
52      {
53          super(metaObjectIn, getContext(context));
54          this.superEnumerationFacade =
55             (EnumerationFacade)
56              MetafacadeFactory.getInstance().createFacadeImpl(
57                      "org.andromda.metafacades.uml.EnumerationFacade",
58                      metaObjectIn,
59                      getContext(context));
60          this.metaObject = metaObjectIn;
61      }
62  
63      /**
64       * Gets the context for this metafacade logic instance.
65       * @param context String. Set to HibernateEnumeration if null
66       * @return context String
67       */
68      private static String getContext(String context)
69      {
70          if (context == null)
71          {
72              context = "org.andromda.cartridges.hibernate.metafacades.HibernateEnumeration";
73          }
74          return context;
75      }
76  
77      private EnumerationFacade superEnumerationFacade;
78      private boolean superEnumerationFacadeInitialized = false;
79  
80      /**
81       * Gets the EnumerationFacade parent instance.
82       * @return this.superEnumerationFacade EnumerationFacade
83       */
84      private EnumerationFacade getSuperEnumerationFacade()
85      {
86          if (!this.superEnumerationFacadeInitialized)
87          {
88              ((MetafacadeBase)this.superEnumerationFacade).setMetafacadeContext(this.getMetafacadeContext());
89              this.superEnumerationFacadeInitialized = true;
90          }
91          return this.superEnumerationFacade;
92      }
93  
94      /** Reset context only for non-root metafacades
95       * @param context
96       * @see org.andromda.core.metafacade.MetafacadeBase#resetMetafacadeContext(String context)
97       */
98      @Override
99      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 }