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