1 // license-header java merge-point
2 //
3 // Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
4 //
5 package org.andromda.metafacades.uml14;
6
7 import java.util.Collection;
8 import java.util.List;
9 import org.andromda.core.metafacade.MetafacadeBase;
10 import org.andromda.core.metafacade.ModelValidationMessage;
11 import org.andromda.metafacades.uml.AssociationEndFacade;
12 import org.andromda.metafacades.uml.AttributeFacade;
13 import org.andromda.metafacades.uml.ClassifierFacade;
14 import org.andromda.metafacades.uml.ModelElementFacade;
15 import org.andromda.metafacades.uml.OperationFacade;
16 import org.andromda.translation.ocl.validation.OCLCollections;
17 import org.andromda.translation.ocl.validation.OCLIntrospector;
18 import org.andromda.translation.ocl.validation.OCLResultEnsurer;
19 import org.apache.commons.collections.Transformer;
20 import org.apache.log4j.Logger;
21 import org.omg.uml.foundation.core.Classifier;
22
23 /**
24 * A Classifier is a classification of instances - it describes a set of instances that have
25 * features in common. Can specify a generalization hierarchy by referencing its general
26 * classifiers. It may be a Class, DataType, PrimitiveType, Association, Collaboration, UseCase,
27 * etc. Can specify a generalization hierarchy by referencing its general classifiers. Has the
28 * capability to own collaboration uses. These collaboration uses link a collaboration with the
29 * classifier to give a description of the workings of the classifier. Classifier is defined to be a
30 * kind of templateable element so that a classifier can be parameterized. It is also defined to be
31 * a kind of parameterable element so that a classifier can be a formal template parameter.
32 * MetafacadeLogic for ClassifierFacade
33 *
34 * @see ClassifierFacade
35 */
36 public abstract class ClassifierFacadeLogic
37 extends GeneralizableElementFacadeLogicImpl
38 implements ClassifierFacade
39 {
40 /**
41 * The underlying UML object
42 * @see Classifier
43 */
44 protected Classifier metaObject;
45
46 /** Create Metafacade implementation instance using the MetafacadeFactory from the context
47 * @param metaObjectIn
48 * @param context
49 */
50 protected ClassifierFacadeLogic(Classifier metaObjectIn, String context)
51 {
52 super(metaObjectIn, getContext(context));
53 this.metaObject = metaObjectIn;
54 }
55
56 /**
57 * The logger instance.
58 */
59 private static final Logger logger = Logger.getLogger(ClassifierFacadeLogic.class);
60
61 /**
62 * Gets the context for this metafacade logic instance.
63 * @param context String. Set to ClassifierFacade if null
64 * @return context String
65 */
66 private static String getContext(String context)
67 {
68 if (context == null)
69 {
70 context = "org.andromda.metafacades.uml.ClassifierFacade";
71 }
72 return context;
73 }
74
75 /** Reset context only for non-root metafacades
76 * @param context
77 */
78 @Override
79 public void resetMetafacadeContext(String context)
80 {
81 if (!this.contextRoot) // reset context only for non-root metafacades
82 {
83 context = getContext(context); // to have same value as in original constructor call
84 setMetafacadeContext (context);
85 }
86 }
87
88 /**
89 * @return boolean true always
90 * @see ClassifierFacade
91 */
92 public boolean isClassifierFacadeMetaType()
93 {
94 return true;
95 }
96
97 // --------------- attributes ---------------------
98
99 /**
100 * @see ClassifierFacade#isPrimitive()
101 * @return boolean
102 */
103 protected abstract boolean handleIsPrimitive();
104
105 private boolean __primitive1a;
106 private boolean __primitive1aSet = false;
107
108 /**
109 * Indicates whether or not this classifier represents a primitive type.
110 * @return (boolean)handleIsPrimitive()
111 */
112 public final boolean isPrimitive()
113 {
114 boolean primitive1a = this.__primitive1a;
115 if (!this.__primitive1aSet)
116 {
117 // primitive has no pre constraints
118 primitive1a = handleIsPrimitive();
119 // primitive has no post constraints
120 this.__primitive1a = primitive1a;
121 if (isMetafacadePropertyCachingEnabled())
122 {
123 this.__primitive1aSet = true;
124 }
125 }
126 return primitive1a;
127 }
128
129 /**
130 * @see ClassifierFacade#getOperationCallFromAttributes()
131 * @return String
132 */
133 protected abstract String handleGetOperationCallFromAttributes();
134
135 private String __operationCallFromAttributes2a;
136 private boolean __operationCallFromAttributes2aSet = false;
137
138 /**
139 * The attributes from this classifier in the form of an operation call (this example would be
140 * in Java): '(String attributeOne, String attributeTwo). If there were no attributes on the
141 * classifier, the result would be an empty '()'.
142 * @return (String)handleGetOperationCallFromAttributes()
143 */
144 public final String getOperationCallFromAttributes()
145 {
146 String operationCallFromAttributes2a = this.__operationCallFromAttributes2a;
147 if (!this.__operationCallFromAttributes2aSet)
148 {
149 // operationCallFromAttributes has no pre constraints
150 operationCallFromAttributes2a = handleGetOperationCallFromAttributes();
151 // operationCallFromAttributes has no post constraints
152 this.__operationCallFromAttributes2a = operationCallFromAttributes2a;
153 if (isMetafacadePropertyCachingEnabled())
154 {
155 this.__operationCallFromAttributes2aSet = true;
156 }
157 }
158 return operationCallFromAttributes2a;
159 }
160
161 /**
162 * @see ClassifierFacade#isAbstract()
163 * @return boolean
164 */
165 protected abstract boolean handleIsAbstract();
166
167 private boolean __abstract3a;
168 private boolean __abstract3aSet = false;
169
170 /**
171 * Indicates if this classifier is 'abstract'.
172 * @return (boolean)handleIsAbstract()
173 */
174 public final boolean isAbstract()
175 {
176 boolean abstract3a = this.__abstract3a;
177 if (!this.__abstract3aSet)
178 {
179 // abstract has no pre constraints
180 abstract3a = handleIsAbstract();
181 // abstract has no post constraints
182 this.__abstract3a = abstract3a;
183 if (isMetafacadePropertyCachingEnabled())
184 {
185 this.__abstract3aSet = true;
186 }
187 }
188 return abstract3a;
189 }
190
191 /**
192 * @see ClassifierFacade#isDataType()
193 * @return boolean
194 */
195 protected abstract boolean handleIsDataType();
196
197 private boolean __dataType4a;
198 private boolean __dataType4aSet = false;
199
200 /**
201 * True/false depending on whether or not this classifier represents a datatype. A data type is
202 * a type whose instances are identified only by their value. A data type may contain attributes
203 * to support the modeling of structured data types.
204 * @return (boolean)handleIsDataType()
205 */
206 public final boolean isDataType()
207 {
208 boolean dataType4a = this.__dataType4a;
209 if (!this.__dataType4aSet)
210 {
211 // dataType has no pre constraints
212 dataType4a = handleIsDataType();
213 // dataType has no post constraints
214 this.__dataType4a = dataType4a;
215 if (isMetafacadePropertyCachingEnabled())
216 {
217 this.__dataType4aSet = true;
218 }
219 }
220 return dataType4a;
221 }
222
223 /**
224 * @see ClassifierFacade#isArrayType()
225 * @return boolean
226 */
227 protected abstract boolean handleIsArrayType();
228
229 private boolean __arrayType5a;
230 private boolean __arrayType5aSet = false;
231
232 /**
233 * True if this classifier represents an array type. False otherwise.
234 * @return (boolean)handleIsArrayType()
235 */
236 public final boolean isArrayType()
237 {
238 boolean arrayType5a = this.__arrayType5a;
239 if (!this.__arrayType5aSet)
240 {
241 // arrayType has no pre constraints
242 arrayType5a = handleIsArrayType();
243 // arrayType has no post constraints
244 this.__arrayType5a = arrayType5a;
245 if (isMetafacadePropertyCachingEnabled())
246 {
247 this.__arrayType5aSet = true;
248 }
249 }
250 return arrayType5a;
251 }
252
253 /**
254 * @see ClassifierFacade#isCollectionType()
255 * @return boolean
256 */
257 protected abstract boolean handleIsCollectionType();
258
259 private boolean __collectionType6a;
260 private boolean __collectionType6aSet = false;
261
262 /**
263 * True if this classifier represents a collection type. False otherwise.
264 * @return (boolean)handleIsCollectionType()
265 */
266 public final boolean isCollectionType()
267 {
268 boolean collectionType6a = this.__collectionType6a;
269 if (!this.__collectionType6aSet)
270 {
271 // collectionType has no pre constraints
272 collectionType6a = handleIsCollectionType();
273 // collectionType has no post constraints
274 this.__collectionType6a = collectionType6a;
275 if (isMetafacadePropertyCachingEnabled())
276 {
277 this.__collectionType6aSet = true;
278 }
279 }
280 return collectionType6a;
281 }
282
283 /**
284 * @see ClassifierFacade#getWrapperName()
285 * @return String
286 */
287 protected abstract String handleGetWrapperName();
288
289 private String __wrapperName7a;
290 private boolean __wrapperName7aSet = false;
291
292 /**
293 * The wrapper name for this classifier if a mapped type has a defined wrapper class (ie. 'long'
294 * maps to 'Long'). If the classifier doesn't have a wrapper defined for it, this method will
295 * return a null. Note that wrapper mappings must be defined for the namespace by defining the
296 * 'wrapperMappingsUri', this property must point to the location of the mappings file which
297 * maps the primitives to wrapper types.
298 * @return (String)handleGetWrapperName()
299 */
300 public final String getWrapperName()
301 {
302 String wrapperName7a = this.__wrapperName7a;
303 if (!this.__wrapperName7aSet)
304 {
305 // wrapperName has no pre constraints
306 wrapperName7a = handleGetWrapperName();
307 // wrapperName has no post constraints
308 this.__wrapperName7a = wrapperName7a;
309 if (isMetafacadePropertyCachingEnabled())
310 {
311 this.__wrapperName7aSet = true;
312 }
313 }
314 return wrapperName7a;
315 }
316
317 /**
318 * @see ClassifierFacade#isDateType()
319 * @return boolean
320 */
321 protected abstract boolean handleIsDateType();
322
323 private boolean __dateType8a;
324 private boolean __dateType8aSet = false;
325
326 /**
327 * True when this classifier is a date type.
328 * @return (boolean)handleIsDateType()
329 */
330 public final boolean isDateType()
331 {
332 boolean dateType8a = this.__dateType8a;
333 if (!this.__dateType8aSet)
334 {
335 // dateType has no pre constraints
336 dateType8a = handleIsDateType();
337 // dateType has no post constraints
338 this.__dateType8a = dateType8a;
339 if (isMetafacadePropertyCachingEnabled())
340 {
341 this.__dateType8aSet = true;
342 }
343 }
344 return dateType8a;
345 }
346
347 /**
348 * @see ClassifierFacade#isInterface()
349 * @return boolean
350 */
351 protected abstract boolean handleIsInterface();
352
353 private boolean __interface9a;
354 private boolean __interface9aSet = false;
355
356 /**
357 * True/false depending on whether or not this Classifier represents an interface.
358 * @return (boolean)handleIsInterface()
359 */
360 public final boolean isInterface()
361 {
362 boolean interface9a = this.__interface9a;
363 if (!this.__interface9aSet)
364 {
365 // interface has no pre constraints
366 interface9a = handleIsInterface();
367 // interface has no post constraints
368 this.__interface9a = interface9a;
369 if (isMetafacadePropertyCachingEnabled())
370 {
371 this.__interface9aSet = true;
372 }
373 }
374 return interface9a;
375 }
376
377 /**
378 * @see ClassifierFacade#getJavaNewString()
379 * @return String
380 */
381 protected abstract String handleGetJavaNewString();
382
383 private String __javaNewString10a;
384 private boolean __javaNewString10aSet = false;
385
386 /**
387 * A String representing a new Constructor declaration for this classifier type to be used in a
388 * Java environment.
389 * @return (String)handleGetJavaNewString()
390 */
391 public final String getJavaNewString()
392 {
393 String javaNewString10a = this.__javaNewString10a;
394 if (!this.__javaNewString10aSet)
395 {
396 // javaNewString has no pre constraints
397 javaNewString10a = handleGetJavaNewString();
398 // javaNewString has no post constraints
399 this.__javaNewString10a = javaNewString10a;
400 if (isMetafacadePropertyCachingEnabled())
401 {
402 this.__javaNewString10aSet = true;
403 }
404 }
405 return javaNewString10a;
406 }
407
408 /**
409 * @see ClassifierFacade#isListType()
410 * @return boolean
411 */
412 protected abstract boolean handleIsListType();
413
414 private boolean __listType11a;
415 private boolean __listType11aSet = false;
416
417 /**
418 * True if this classifier represents a list type. False otherwise.
419 * @return (boolean)handleIsListType()
420 */
421 public final boolean isListType()
422 {
423 boolean listType11a = this.__listType11a;
424 if (!this.__listType11aSet)
425 {
426 // listType has no pre constraints
427 listType11a = handleIsListType();
428 // listType has no post constraints
429 this.__listType11a = listType11a;
430 if (isMetafacadePropertyCachingEnabled())
431 {
432 this.__listType11aSet = true;
433 }
434 }
435 return listType11a;
436 }
437
438 /**
439 * @see ClassifierFacade#isSetType()
440 * @return boolean
441 */
442 protected abstract boolean handleIsSetType();
443
444 private boolean __setType12a;
445 private boolean __setType12aSet = false;
446
447 /**
448 * True if this classifier represents a set type. False otherwise.
449 * @return (boolean)handleIsSetType()
450 */
451 public final boolean isSetType()
452 {
453 boolean setType12a = this.__setType12a;
454 if (!this.__setType12aSet)
455 {
456 // setType has no pre constraints
457 setType12a = handleIsSetType();
458 // setType has no post constraints
459 this.__setType12a = setType12a;
460 if (isMetafacadePropertyCachingEnabled())
461 {
462 this.__setType12aSet = true;
463 }
464 }
465 return setType12a;
466 }
467
468 /**
469 * @see ClassifierFacade#isFileType()
470 * @return boolean
471 */
472 protected abstract boolean handleIsFileType();
473
474 private boolean __fileType13a;
475 private boolean __fileType13aSet = false;
476
477 /**
478 * Returns true if this type represents a 'file' type.
479 * @return (boolean)handleIsFileType()
480 */
481 public final boolean isFileType()
482 {
483 boolean fileType13a = this.__fileType13a;
484 if (!this.__fileType13aSet)
485 {
486 // fileType has no pre constraints
487 fileType13a = handleIsFileType();
488 // fileType has no post constraints
489 this.__fileType13a = fileType13a;
490 if (isMetafacadePropertyCachingEnabled())
491 {
492 this.__fileType13aSet = true;
493 }
494 }
495 return fileType13a;
496 }
497
498 /**
499 * @see ClassifierFacade#isMapType()
500 * @return boolean
501 */
502 protected abstract boolean handleIsMapType();
503
504 private boolean __mapType14a;
505 private boolean __mapType14aSet = false;
506
507 /**
508 * Indicates whether or not this classifier represents a Map type.
509 * @return (boolean)handleIsMapType()
510 */
511 public final boolean isMapType()
512 {
513 boolean mapType14a = this.__mapType14a;
514 if (!this.__mapType14aSet)
515 {
516 // mapType has no pre constraints
517 mapType14a = handleIsMapType();
518 // mapType has no post constraints
519 this.__mapType14a = mapType14a;
520 if (isMetafacadePropertyCachingEnabled())
521 {
522 this.__mapType14aSet = true;
523 }
524 }
525 return mapType14a;
526 }
527
528 /**
529 * @see ClassifierFacade#isStringType()
530 * @return boolean
531 */
532 protected abstract boolean handleIsStringType();
533
534 private boolean __stringType15a;
535 private boolean __stringType15aSet = false;
536
537 /**
538 * Indicates whether or not this classifier represents a string type.
539 * @return (boolean)handleIsStringType()
540 */
541 public final boolean isStringType()
542 {
543 boolean stringType15a = this.__stringType15a;
544 if (!this.__stringType15aSet)
545 {
546 // stringType has no pre constraints
547 stringType15a = handleIsStringType();
548 // stringType has no post constraints
549 this.__stringType15a = stringType15a;
550 if (isMetafacadePropertyCachingEnabled())
551 {
552 this.__stringType15aSet = true;
553 }
554 }
555 return stringType15a;
556 }
557
558 /**
559 * @see ClassifierFacade#isEnumeration()
560 * @return boolean
561 */
562 protected abstract boolean handleIsEnumeration();
563
564 private boolean __enumeration16a;
565 private boolean __enumeration16aSet = false;
566
567 /**
568 * True if this classifier is in fact marked as an enumeration.
569 * @return (boolean)handleIsEnumeration()
570 */
571 public final boolean isEnumeration()
572 {
573 boolean enumeration16a = this.__enumeration16a;
574 if (!this.__enumeration16aSet)
575 {
576 // enumeration has no pre constraints
577 enumeration16a = handleIsEnumeration();
578 // enumeration has no post constraints
579 this.__enumeration16a = enumeration16a;
580 if (isMetafacadePropertyCachingEnabled())
581 {
582 this.__enumeration16aSet = true;
583 }
584 }
585 return enumeration16a;
586 }
587
588 /**
589 * @see ClassifierFacade#getArrayName()
590 * @return String
591 */
592 protected abstract String handleGetArrayName();
593
594 private String __arrayName17a;
595 private boolean __arrayName17aSet = false;
596
597 /**
598 * The name of the classifier as an array.
599 * @return (String)handleGetArrayName()
600 */
601 public final String getArrayName()
602 {
603 String arrayName17a = this.__arrayName17a;
604 if (!this.__arrayName17aSet)
605 {
606 // arrayName has no pre constraints
607 arrayName17a = handleGetArrayName();
608 // arrayName has no post constraints
609 this.__arrayName17a = arrayName17a;
610 if (isMetafacadePropertyCachingEnabled())
611 {
612 this.__arrayName17aSet = true;
613 }
614 }
615 return arrayName17a;
616 }
617
618 /**
619 * @see ClassifierFacade#getFullyQualifiedArrayName()
620 * @return String
621 */
622 protected abstract String handleGetFullyQualifiedArrayName();
623
624 private String __fullyQualifiedArrayName18a;
625 private boolean __fullyQualifiedArrayName18aSet = false;
626
627 /**
628 * The fully qualified name of the classifier as an array.
629 * @return (String)handleGetFullyQualifiedArrayName()
630 */
631 public final String getFullyQualifiedArrayName()
632 {
633 String fullyQualifiedArrayName18a = this.__fullyQualifiedArrayName18a;
634 if (!this.__fullyQualifiedArrayName18aSet)
635 {
636 // fullyQualifiedArrayName has no pre constraints
637 fullyQualifiedArrayName18a = handleGetFullyQualifiedArrayName();
638 // fullyQualifiedArrayName has no post constraints
639 this.__fullyQualifiedArrayName18a = fullyQualifiedArrayName18a;
640 if (isMetafacadePropertyCachingEnabled())
641 {
642 this.__fullyQualifiedArrayName18aSet = true;
643 }
644 }
645 return fullyQualifiedArrayName18a;
646 }
647
648 /**
649 * @see ClassifierFacade#getSerialVersionUID()
650 * @return long
651 */
652 protected abstract long handleGetSerialVersionUID();
653
654 private long __serialVersionUID19a;
655 private boolean __serialVersionUID19aSet = false;
656
657 /**
658 * Returns the serial version UID of the underlying model element.
659 * @return (long)handleGetSerialVersionUID()
660 */
661 public final long getSerialVersionUID()
662 {
663 long serialVersionUID19a = this.__serialVersionUID19a;
664 if (!this.__serialVersionUID19aSet)
665 {
666 // serialVersionUID has no pre constraints
667 serialVersionUID19a = handleGetSerialVersionUID();
668 // serialVersionUID has no post constraints
669 this.__serialVersionUID19a = serialVersionUID19a;
670 if (isMetafacadePropertyCachingEnabled())
671 {
672 this.__serialVersionUID19aSet = true;
673 }
674 }
675 return serialVersionUID19a;
676 }
677
678 /**
679 * @see ClassifierFacade#isBlobType()
680 * @return boolean
681 */
682 protected abstract boolean handleIsBlobType();
683
684 private boolean __blobType20a;
685 private boolean __blobType20aSet = false;
686
687 /**
688 * Returns true if this type represents a Blob type.
689 * @return (boolean)handleIsBlobType()
690 */
691 public final boolean isBlobType()
692 {
693 boolean blobType20a = this.__blobType20a;
694 if (!this.__blobType20aSet)
695 {
696 // blobType has no pre constraints
697 blobType20a = handleIsBlobType();
698 // blobType has no post constraints
699 this.__blobType20a = blobType20a;
700 if (isMetafacadePropertyCachingEnabled())
701 {
702 this.__blobType20aSet = true;
703 }
704 }
705 return blobType20a;
706 }
707
708 /**
709 * @see ClassifierFacade#isBooleanType()
710 * @return boolean
711 */
712 protected abstract boolean handleIsBooleanType();
713
714 private boolean __booleanType21a;
715 private boolean __booleanType21aSet = false;
716
717 /**
718 * Indicates if this type represents a boolean type or not.
719 * @return (boolean)handleIsBooleanType()
720 */
721 public final boolean isBooleanType()
722 {
723 boolean booleanType21a = this.__booleanType21a;
724 if (!this.__booleanType21aSet)
725 {
726 // booleanType has no pre constraints
727 booleanType21a = handleIsBooleanType();
728 // booleanType has no post constraints
729 this.__booleanType21a = booleanType21a;
730 if (isMetafacadePropertyCachingEnabled())
731 {
732 this.__booleanType21aSet = true;
733 }
734 }
735 return booleanType21a;
736 }
737
738 /**
739 * @see ClassifierFacade#isTimeType()
740 * @return boolean
741 */
742 protected abstract boolean handleIsTimeType();
743
744 private boolean __timeType22a;
745 private boolean __timeType22aSet = false;
746
747 /**
748 * Indicates whether or not this classifier represents a time type.
749 * @return (boolean)handleIsTimeType()
750 */
751 public final boolean isTimeType()
752 {
753 boolean timeType22a = this.__timeType22a;
754 if (!this.__timeType22aSet)
755 {
756 // timeType has no pre constraints
757 timeType22a = handleIsTimeType();
758 // timeType has no post constraints
759 this.__timeType22a = timeType22a;
760 if (isMetafacadePropertyCachingEnabled())
761 {
762 this.__timeType22aSet = true;
763 }
764 }
765 return timeType22a;
766 }
767
768 /**
769 * @see ClassifierFacade#isLeaf()
770 * @return boolean
771 */
772 protected abstract boolean handleIsLeaf();
773
774 private boolean __leaf23a;
775 private boolean __leaf23aSet = false;
776
777 /**
778 * True if this classifier cannot be extended and represent a leaf in the inheritance tree.
779 * @return (boolean)handleIsLeaf()
780 */
781 public final boolean isLeaf()
782 {
783 boolean leaf23a = this.__leaf23a;
784 if (!this.__leaf23aSet)
785 {
786 // leaf has no pre constraints
787 leaf23a = handleIsLeaf();
788 // leaf has no post constraints
789 this.__leaf23a = leaf23a;
790 if (isMetafacadePropertyCachingEnabled())
791 {
792 this.__leaf23aSet = true;
793 }
794 }
795 return leaf23a;
796 }
797
798 /**
799 * @see ClassifierFacade#getImplementedInterfaceList()
800 * @return String
801 */
802 protected abstract String handleGetImplementedInterfaceList();
803
804 private String __implementedInterfaceList24a;
805 private boolean __implementedInterfaceList24aSet = false;
806
807 /**
808 * A comma separated list of the fully qualified names of all implemented interfaces.
809 * @return (String)handleGetImplementedInterfaceList()
810 */
811 public final String getImplementedInterfaceList()
812 {
813 String implementedInterfaceList24a = this.__implementedInterfaceList24a;
814 if (!this.__implementedInterfaceList24aSet)
815 {
816 // implementedInterfaceList has no pre constraints
817 implementedInterfaceList24a = handleGetImplementedInterfaceList();
818 // implementedInterfaceList has no post constraints
819 this.__implementedInterfaceList24a = implementedInterfaceList24a;
820 if (isMetafacadePropertyCachingEnabled())
821 {
822 this.__implementedInterfaceList24aSet = true;
823 }
824 }
825 return implementedInterfaceList24a;
826 }
827
828 /**
829 * @see ClassifierFacade#getRequiredConstructorParameters()
830 * @return Collection<ModelElementFacade>
831 */
832 protected abstract Collection<ModelElementFacade> handleGetRequiredConstructorParameters();
833
834 private Collection<ModelElementFacade> __requiredConstructorParameters25a;
835 private boolean __requiredConstructorParameters25aSet = false;
836
837 /**
838 * A collection containing all required and/or read-only 'properties' of the classifier.
839 * Properties are any attributes and navigable connecting association ends.
840 * @return (Collection<ModelElementFacade>)handleGetRequiredConstructorParameters()
841 */
842 public final Collection<ModelElementFacade> getRequiredConstructorParameters()
843 {
844 Collection<ModelElementFacade> requiredConstructorParameters25a = this.__requiredConstructorParameters25a;
845 if (!this.__requiredConstructorParameters25aSet)
846 {
847 // requiredConstructorParameters has no pre constraints
848 requiredConstructorParameters25a = handleGetRequiredConstructorParameters();
849 // requiredConstructorParameters has no post constraints
850 this.__requiredConstructorParameters25a = requiredConstructorParameters25a;
851 if (isMetafacadePropertyCachingEnabled())
852 {
853 this.__requiredConstructorParameters25aSet = true;
854 }
855 }
856 return requiredConstructorParameters25a;
857 }
858
859 /**
860 * @see ClassifierFacade#getAllRequiredConstructorParameters()
861 * @return Collection<ModelElementFacade>
862 */
863 protected abstract Collection<ModelElementFacade> handleGetAllRequiredConstructorParameters();
864
865 private Collection<ModelElementFacade> __allRequiredConstructorParameters26a;
866 private boolean __allRequiredConstructorParameters26aSet = false;
867
868 /**
869 * A collection containing all required and/or read-only 'properties' of the classifier and its
870 * ancestors. Properties are any attributes and navigable connecting association ends.
871 * @return (Collection<ModelElementFacade>)handleGetAllRequiredConstructorParameters()
872 */
873 public final Collection<ModelElementFacade> getAllRequiredConstructorParameters()
874 {
875 Collection<ModelElementFacade> allRequiredConstructorParameters26a = this.__allRequiredConstructorParameters26a;
876 if (!this.__allRequiredConstructorParameters26aSet)
877 {
878 // allRequiredConstructorParameters has no pre constraints
879 allRequiredConstructorParameters26a = handleGetAllRequiredConstructorParameters();
880 // allRequiredConstructorParameters has no post constraints
881 this.__allRequiredConstructorParameters26a = allRequiredConstructorParameters26a;
882 if (isMetafacadePropertyCachingEnabled())
883 {
884 this.__allRequiredConstructorParameters26aSet = true;
885 }
886 }
887 return allRequiredConstructorParameters26a;
888 }
889
890 /**
891 * @see ClassifierFacade#getProperties()
892 * @return List<ModelElementFacade>
893 */
894 protected abstract List<ModelElementFacade> handleGetProperties();
895
896 private List<ModelElementFacade> __properties27a;
897 private boolean __properties27aSet = false;
898
899 /**
900 * A collection containing all 'properties' of the classifier. Properties are any attributes
901 * and navigable connecting association ends.
902 * @return (List<ModelElementFacade>)handleGetProperties()
903 */
904 public final List<ModelElementFacade> getProperties()
905 {
906 List<ModelElementFacade> properties27a = this.__properties27a;
907 if (!this.__properties27aSet)
908 {
909 // properties has no pre constraints
910 properties27a = handleGetProperties();
911 // properties has no post constraints
912 this.__properties27a = properties27a;
913 if (isMetafacadePropertyCachingEnabled())
914 {
915 this.__properties27aSet = true;
916 }
917 }
918 return properties27a;
919 }
920
921 /**
922 * @see ClassifierFacade#getAllProperties()
923 * @return Collection<ModelElementFacade>
924 */
925 protected abstract Collection<ModelElementFacade> handleGetAllProperties();
926
927 private Collection<ModelElementFacade> __allProperties28a;
928 private boolean __allProperties28aSet = false;
929
930 /**
931 * A collection containing all 'properties' of the classifier and its ancestors. Properties are
932 * any attributes and navigable connecting association ends.
933 * @return (Collection<ModelElementFacade>)handleGetAllProperties()
934 */
935 public final Collection<ModelElementFacade> getAllProperties()
936 {
937 Collection<ModelElementFacade> allProperties28a = this.__allProperties28a;
938 if (!this.__allProperties28aSet)
939 {
940 // allProperties has no pre constraints
941 allProperties28a = handleGetAllProperties();
942 // allProperties has no post constraints
943 this.__allProperties28a = allProperties28a;
944 if (isMetafacadePropertyCachingEnabled())
945 {
946 this.__allProperties28aSet = true;
947 }
948 }
949 return allProperties28a;
950 }
951
952 /**
953 * @see ClassifierFacade#isAssociationClass()
954 * @return boolean
955 */
956 protected abstract boolean handleIsAssociationClass();
957
958 private boolean __associationClass29a;
959 private boolean __associationClass29aSet = false;
960
961 /**
962 * True if the ClassifierFacade is an AssociationClass.
963 * @return (boolean)handleIsAssociationClass()
964 */
965 public final boolean isAssociationClass()
966 {
967 boolean associationClass29a = this.__associationClass29a;
968 if (!this.__associationClass29aSet)
969 {
970 // associationClass has no pre constraints
971 associationClass29a = handleIsAssociationClass();
972 // associationClass has no post constraints
973 this.__associationClass29a = associationClass29a;
974 if (isMetafacadePropertyCachingEnabled())
975 {
976 this.__associationClass29aSet = true;
977 }
978 }
979 return associationClass29a;
980 }
981
982 /**
983 * @see ClassifierFacade#isClobType()
984 * @return boolean
985 */
986 protected abstract boolean handleIsClobType();
987
988 private boolean __clobType30a;
989 private boolean __clobType30aSet = false;
990
991 /**
992 * Returns true if this type represents a Clob type.
993 * @return (boolean)handleIsClobType()
994 */
995 public final boolean isClobType()
996 {
997 boolean clobType30a = this.__clobType30a;
998 if (!this.__clobType30aSet)
999 {
1000 // clobType has no pre constraints
1001 clobType30a = handleIsClobType();
1002 // clobType has no post constraints
1003 this.__clobType30a = clobType30a;
1004 if (isMetafacadePropertyCachingEnabled())
1005 {
1006 this.__clobType30aSet = true;
1007 }
1008 }
1009 return clobType30a;
1010 }
1011
1012 /**
1013 * @see ClassifierFacade#isEmbeddedValue()
1014 * @return boolean
1015 */
1016 protected abstract boolean handleIsEmbeddedValue();
1017
1018 private boolean __embeddedValue31a;
1019 private boolean __embeddedValue31aSet = false;
1020
1021 /**
1022 * Indicates whether or not this classifier represents an "EmbeddedValue'.
1023 * @return (boolean)handleIsEmbeddedValue()
1024 */
1025 public final boolean isEmbeddedValue()
1026 {
1027 boolean embeddedValue31a = this.__embeddedValue31a;
1028 if (!this.__embeddedValue31aSet)
1029 {
1030 // embeddedValue has no pre constraints
1031 embeddedValue31a = handleIsEmbeddedValue();
1032 // embeddedValue has no post constraints
1033 this.__embeddedValue31a = embeddedValue31a;
1034 if (isMetafacadePropertyCachingEnabled())
1035 {
1036 this.__embeddedValue31aSet = true;
1037 }
1038 }
1039 return embeddedValue31a;
1040 }
1041
1042 /**
1043 * @see ClassifierFacade#isIntegerType()
1044 * @return boolean
1045 */
1046 protected abstract boolean handleIsIntegerType();
1047
1048 private boolean __integerType32a;
1049 private boolean __integerType32aSet = false;
1050
1051 /**
1052 * Indicates if this type represents an int or Integer or java.lang.Integer type or not.
1053 * @return (boolean)handleIsIntegerType()
1054 */
1055 public final boolean isIntegerType()
1056 {
1057 boolean integerType32a = this.__integerType32a;
1058 if (!this.__integerType32aSet)
1059 {
1060 // integerType has no pre constraints
1061 integerType32a = handleIsIntegerType();
1062 // integerType has no post constraints
1063 this.__integerType32a = integerType32a;
1064 if (isMetafacadePropertyCachingEnabled())
1065 {
1066 this.__integerType32aSet = true;
1067 }
1068 }
1069 return integerType32a;
1070 }
1071
1072 /**
1073 * @see ClassifierFacade#isFloatType()
1074 * @return boolean
1075 */
1076 protected abstract boolean handleIsFloatType();
1077
1078 private boolean __floatType33a;
1079 private boolean __floatType33aSet = false;
1080
1081 /**
1082 * Indicates if this type represents a Float type or not.
1083 * @return (boolean)handleIsFloatType()
1084 */
1085 public final boolean isFloatType()
1086 {
1087 boolean floatType33a = this.__floatType33a;
1088 if (!this.__floatType33aSet)
1089 {
1090 // floatType has no pre constraints
1091 floatType33a = handleIsFloatType();
1092 // floatType has no post constraints
1093 this.__floatType33a = floatType33a;
1094 if (isMetafacadePropertyCachingEnabled())
1095 {
1096 this.__floatType33aSet = true;
1097 }
1098 }
1099 return floatType33a;
1100 }
1101
1102 /**
1103 * @see ClassifierFacade#isLongType()
1104 * @return boolean
1105 */
1106 protected abstract boolean handleIsLongType();
1107
1108 private boolean __longType34a;
1109 private boolean __longType34aSet = false;
1110
1111 /**
1112 * Indicates if this type represents a Long type or not.
1113 * @return (boolean)handleIsLongType()
1114 */
1115 public final boolean isLongType()
1116 {
1117 boolean longType34a = this.__longType34a;
1118 if (!this.__longType34aSet)
1119 {
1120 // longType has no pre constraints
1121 longType34a = handleIsLongType();
1122 // longType has no post constraints
1123 this.__longType34a = longType34a;
1124 if (isMetafacadePropertyCachingEnabled())
1125 {
1126 this.__longType34aSet = true;
1127 }
1128 }
1129 return longType34a;
1130 }
1131
1132 /**
1133 * @see ClassifierFacade#isDoubleType()
1134 * @return boolean
1135 */
1136 protected abstract boolean handleIsDoubleType();
1137
1138 private boolean __doubleType35a;
1139 private boolean __doubleType35aSet = false;
1140
1141 /**
1142 * Indicates if this type represents a Double type or not.
1143 * @return (boolean)handleIsDoubleType()
1144 */
1145 public final boolean isDoubleType()
1146 {
1147 boolean doubleType35a = this.__doubleType35a;
1148 if (!this.__doubleType35aSet)
1149 {
1150 // doubleType has no pre constraints
1151 doubleType35a = handleIsDoubleType();
1152 // doubleType has no post constraints
1153 this.__doubleType35a = doubleType35a;
1154 if (isMetafacadePropertyCachingEnabled())
1155 {
1156 this.__doubleType35aSet = true;
1157 }
1158 }
1159 return doubleType35a;
1160 }
1161
1162 /**
1163 * @see ClassifierFacade#isWrappedPrimitive()
1164 * @return boolean
1165 */
1166 protected abstract boolean handleIsWrappedPrimitive();
1167
1168 private boolean __wrappedPrimitive36a;
1169 private boolean __wrappedPrimitive36aSet = false;
1170
1171 /**
1172 * Returns true if this type is a wrapped primitive type.
1173 * @return (boolean)handleIsWrappedPrimitive()
1174 */
1175 public final boolean isWrappedPrimitive()
1176 {
1177 boolean wrappedPrimitive36a = this.__wrappedPrimitive36a;
1178 if (!this.__wrappedPrimitive36aSet)
1179 {
1180 // wrappedPrimitive has no pre constraints
1181 wrappedPrimitive36a = handleIsWrappedPrimitive();
1182 // wrappedPrimitive has no post constraints
1183 this.__wrappedPrimitive36a = wrappedPrimitive36a;
1184 if (isMetafacadePropertyCachingEnabled())
1185 {
1186 this.__wrappedPrimitive36aSet = true;
1187 }
1188 }
1189 return wrappedPrimitive36a;
1190 }
1191
1192 /**
1193 * @see ClassifierFacade#getJavaNullString()
1194 * @return String
1195 */
1196 protected abstract String handleGetJavaNullString();
1197
1198 private String __javaNullString37a;
1199 private boolean __javaNullString37aSet = false;
1200
1201 /**
1202 * A String representing the null-value for this classifier type to be used in a Java
1203 * environment.
1204 * @return (String)handleGetJavaNullString()
1205 */
1206 public final String getJavaNullString()
1207 {
1208 String javaNullString37a = this.__javaNullString37a;
1209 if (!this.__javaNullString37aSet)
1210 {
1211 // javaNullString has no pre constraints
1212 javaNullString37a = handleGetJavaNullString();
1213 // javaNullString has no post constraints
1214 this.__javaNullString37a = javaNullString37a;
1215 if (isMetafacadePropertyCachingEnabled())
1216 {
1217 this.__javaNullString37aSet = true;
1218 }
1219 }
1220 return javaNullString37a;
1221 }
1222
1223 /**
1224 * @see ClassifierFacade#isCharacterType()
1225 * @return boolean
1226 */
1227 protected abstract boolean handleIsCharacterType();
1228
1229 private boolean __characterType38a;
1230 private boolean __characterType38aSet = false;
1231
1232 /**
1233 * Indicates if this type represents a char, Character, or java.lang.Character type or not.
1234 * @return (boolean)handleIsCharacterType()
1235 */
1236 public final boolean isCharacterType()
1237 {
1238 boolean characterType38a = this.__characterType38a;
1239 if (!this.__characterType38aSet)
1240 {
1241 // characterType has no pre constraints
1242 characterType38a = handleIsCharacterType();
1243 // characterType has no post constraints
1244 this.__characterType38a = characterType38a;
1245 if (isMetafacadePropertyCachingEnabled())
1246 {
1247 this.__characterType38aSet = true;
1248 }
1249 }
1250 return characterType38a;
1251 }
1252
1253 // ---------------- business methods ----------------------
1254
1255 /**
1256 * Method to be implemented in descendants
1257 * Gets all attributes for the classifier and if 'follow' is true goes up the inheritance
1258 * hierarchy and gets the attributes from the super classes as well.
1259 * @param follow
1260 * @return List<AttributeFacade>
1261 */
1262 protected abstract List<AttributeFacade> handleGetAttributes(boolean follow);
1263
1264 /**
1265 * Gets all attributes for the classifier and if 'follow' is true goes up the inheritance
1266 * hierarchy and gets the attributes from the super classes as well.
1267 * @param follow boolean
1268 * Whether or not to follow the inheritance hierarchy when retrieveing attributes.
1269 * @return handleGetAttributes(follow)
1270 */
1271 public List<AttributeFacade> getAttributes(boolean follow)
1272 {
1273 // getAttributes has no pre constraints
1274 List<AttributeFacade> returnValue = handleGetAttributes(follow);
1275 // getAttributes has no post constraints
1276 return returnValue;
1277 }
1278
1279 /**
1280 * Method to be implemented in descendants
1281 * Return the attribute which name matches the parameter
1282 * @param name
1283 * @return AttributeFacade
1284 */
1285 protected abstract AttributeFacade handleFindAttribute(String name);
1286
1287 /**
1288 * Return the attribute which name matches the parameter
1289 * @param name String
1290 * TODO: Model Documentation for
1291 * ClassifierFacade.findAttribute(name)
1292 * @return handleFindAttribute(name)
1293 */
1294 public AttributeFacade findAttribute(String name)
1295 {
1296 // findAttribute has no pre constraints
1297 AttributeFacade returnValue = handleFindAttribute(name);
1298 // findAttribute has no post constraints
1299 return returnValue;
1300 }
1301
1302 /**
1303 * Method to be implemented in descendants
1304 * Gets all properties (attributes and navigable association ends) for the classifier and if
1305 * 'follow' is true goes up the inheritance hierarchy and gets the properties from the super
1306 * classes as well.
1307 * @param follow
1308 * @return List
1309 */
1310 protected abstract List handleGetProperties(boolean follow);
1311
1312 /**
1313 * Gets all properties (attributes and navigable association ends) for the classifier and if
1314 * 'follow' is true goes up the inheritance hierarchy and gets the properties from the super
1315 * classes as well.
1316 * @param follow boolean
1317 * TODO: Model Documentation for
1318 * ClassifierFacade.getProperties(follow)
1319 * @return handleGetProperties(follow)
1320 */
1321 public List getProperties(boolean follow)
1322 {
1323 // getProperties has no pre constraints
1324 List returnValue = handleGetProperties(follow);
1325 // getProperties has no post constraints
1326 return returnValue;
1327 }
1328
1329 /**
1330 * Method to be implemented in descendants
1331 * Get the other ends of this classifier's association ends which are navigable and if 'follow'
1332 * is true goes up the inheritance hierarchy and gets the super association ends as well.
1333 * @param follow
1334 * @return List<AssociationEndFacade>
1335 */
1336 protected abstract List<AssociationEndFacade> handleGetNavigableConnectingEnds(boolean follow);
1337
1338 /**
1339 * Get the other ends of this classifier's association ends which are navigable and if 'follow'
1340 * is true goes up the inheritance hierarchy and gets the super association ends as well.
1341 * @param follow boolean
1342 * Whether or not to follow the inheritance hierarchy when retrieving navicables.
1343 * @return handleGetNavigableConnectingEnds(follow)
1344 */
1345 public List<AssociationEndFacade> getNavigableConnectingEnds(boolean follow)
1346 {
1347 // getNavigableConnectingEnds has no pre constraints
1348 List<AssociationEndFacade> returnValue = handleGetNavigableConnectingEnds(follow);
1349 // getNavigableConnectingEnds has no post constraints
1350 return returnValue;
1351 }
1352
1353 // ------------- associations ------------------
1354
1355 private ClassifierFacade __getArray1r;
1356 private boolean __getArray1rSet = false;
1357
1358 /**
1359 * Assuming that the classifier is an array, this will return the non array type of the
1360 * classifier from
1361 * the model. If the classifier is NOT an array, it will just return itself.
1362 * @return (ClassifierFacade)handleGetArray()
1363 */
1364 public final ClassifierFacade getArray()
1365 {
1366 ClassifierFacade getArray1r = this.__getArray1r;
1367 if (!this.__getArray1rSet)
1368 {
1369 // nonArray has no pre constraints
1370 Object result = handleGetArray();
1371 MetafacadeBase shieldedResult = this.shieldedElement(result);
1372 try
1373 {
1374 getArray1r = (ClassifierFacade)shieldedResult;
1375 }
1376 catch (ClassCastException ex)
1377 {
1378 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1379 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getArray ClassifierFacade " + result + ": " + shieldedResult);
1380 }
1381 // nonArray has no post constraints
1382 this.__getArray1r = getArray1r;
1383 if (isMetafacadePropertyCachingEnabled())
1384 {
1385 this.__getArray1rSet = true;
1386 }
1387 }
1388 return getArray1r;
1389 }
1390
1391 /**
1392 * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
1393 * @return Object
1394 */
1395 protected abstract Object handleGetArray();
1396
1397 /**
1398 * A Classifier is a classification of instances - it describes a set of instances that have
1399 * features
1400 * in common. Can specify a generalization hierarchy by referencing its general classifiers. It
1401 * may be
1402 * a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
1403 * generalization hierarchy by referencing its general classifiers. Has the capability to own
1404 * collaboration uses. These collaboration uses link a collaboration with the classifier to give
1405 * a
1406 * description of the workings of the classifier. Classifier is defined to be a kind of
1407 * templateable
1408 * element so that a classifier can be parameterized. It is also defined to be a kind of
1409 * parameterable
1410 * element so that a classifier can be a formal template parameter.
1411 * @return (List<OperationFacade>)handleGetInstanceOperations()
1412 */
1413 public final List<OperationFacade> getInstanceOperations()
1414 {
1415 List<OperationFacade> getInstanceOperations2r = null;
1416 // classifierFacade has no pre constraints
1417 List result = handleGetInstanceOperations();
1418 List shieldedResult = this.shieldedElements(result);
1419 try
1420 {
1421 getInstanceOperations2r = (List<OperationFacade>)shieldedResult;
1422 }
1423 catch (ClassCastException ex)
1424 {
1425 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1426 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getInstanceOperations List<OperationFacade> " + result + ": " + shieldedResult);
1427 }
1428 // classifierFacade has no post constraints
1429 return getInstanceOperations2r;
1430 }
1431
1432 /**
1433 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
1434 * @return List
1435 */
1436 protected abstract List handleGetInstanceOperations();
1437
1438 /**
1439 * Gets the owner of this operation
1440 * @return (List<OperationFacade>)handleGetOperations()
1441 */
1442 public final List<OperationFacade> getOperations()
1443 {
1444 List<OperationFacade> getOperations3r = null;
1445 // owner has no pre constraints
1446 List result = handleGetOperations();
1447 List shieldedResult = this.shieldedElements(result);
1448 try
1449 {
1450 getOperations3r = (List<OperationFacade>)shieldedResult;
1451 }
1452 catch (ClassCastException ex)
1453 {
1454 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1455 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getOperations List<OperationFacade> " + result + ": " + shieldedResult);
1456 }
1457 // owner has no post constraints
1458 return getOperations3r;
1459 }
1460
1461 /**
1462 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
1463 * @return List
1464 */
1465 protected abstract List handleGetOperations();
1466
1467 /**
1468 * A Classifier is a classification of instances - it describes a set of instances that have
1469 * features
1470 * in common. Can specify a generalization hierarchy by referencing its general classifiers. It
1471 * may be
1472 * a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
1473 * generalization hierarchy by referencing its general classifiers. Has the capability to own
1474 * collaboration uses. These collaboration uses link a collaboration with the classifier to give
1475 * a
1476 * description of the workings of the classifier. Classifier is defined to be a kind of
1477 * templateable
1478 * element so that a classifier can be parameterized. It is also defined to be a kind of
1479 * parameterable
1480 * element so that a classifier can be a formal template parameter.
1481 * @return (List<OperationFacade>)handleGetStaticOperations()
1482 */
1483 public final List<OperationFacade> getStaticOperations()
1484 {
1485 List<OperationFacade> getStaticOperations4r = null;
1486 // classifierFacade has no pre constraints
1487 List result = handleGetStaticOperations();
1488 List shieldedResult = this.shieldedElements(result);
1489 try
1490 {
1491 getStaticOperations4r = (List<OperationFacade>)shieldedResult;
1492 }
1493 catch (ClassCastException ex)
1494 {
1495 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1496 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getStaticOperations List<OperationFacade> " + result + ": " + shieldedResult);
1497 }
1498 // classifierFacade has no post constraints
1499 return getStaticOperations4r;
1500 }
1501
1502 /**
1503 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
1504 * @return List
1505 */
1506 protected abstract List handleGetStaticOperations();
1507
1508 /**
1509 * A Classifier is a classification of instances - it describes a set of instances that have
1510 * features
1511 * in common. Can specify a generalization hierarchy by referencing its general classifiers. It
1512 * may be
1513 * a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
1514 * generalization hierarchy by referencing its general classifiers. Has the capability to own
1515 * collaboration uses. These collaboration uses link a collaboration with the classifier to give
1516 * a
1517 * description of the workings of the classifier. Classifier is defined to be a kind of
1518 * templateable
1519 * element so that a classifier can be parameterized. It is also defined to be a kind of
1520 * parameterable
1521 * element so that a classifier can be a formal template parameter.
1522 * @return (Collection<ClassifierFacade>)handleGetAbstractions()
1523 */
1524 public final Collection<ClassifierFacade> getAbstractions()
1525 {
1526 Collection<ClassifierFacade> getAbstractions5r = null;
1527 // classifierFacade has no pre constraints
1528 Collection result = handleGetAbstractions();
1529 List shieldedResult = this.shieldedElements(result);
1530 try
1531 {
1532 getAbstractions5r = (Collection<ClassifierFacade>)shieldedResult;
1533 }
1534 catch (ClassCastException ex)
1535 {
1536 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1537 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getAbstractions Collection<ClassifierFacade> " + result + ": " + shieldedResult);
1538 }
1539 // classifierFacade has no post constraints
1540 return getAbstractions5r;
1541 }
1542
1543 /**
1544 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
1545 * @return Collection
1546 */
1547 protected abstract Collection handleGetAbstractions();
1548
1549 /**
1550 * Gets the classifier who is the owner of the attributes.
1551 * @return (List<AttributeFacade>)handleGetAttributes()
1552 */
1553 public final List<AttributeFacade> getAttributes()
1554 {
1555 List<AttributeFacade> getAttributes6r = null;
1556 // owner has no pre constraints
1557 List result = handleGetAttributes();
1558 List shieldedResult = this.shieldedElements(result);
1559 try
1560 {
1561 getAttributes6r = (List<AttributeFacade>)shieldedResult;
1562 }
1563 catch (ClassCastException ex)
1564 {
1565 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1566 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getAttributes List<AttributeFacade> " + result + ": " + shieldedResult);
1567 }
1568 // owner has no post constraints
1569 return getAttributes6r;
1570 }
1571
1572 /**
1573 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
1574 * @return List
1575 */
1576 protected abstract List handleGetAttributes();
1577
1578 /**
1579 * A Classifier is a classification of instances - it describes a set of instances that have
1580 * features
1581 * in common. Can specify a generalization hierarchy by referencing its general classifiers. It
1582 * may be
1583 * a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
1584 * generalization hierarchy by referencing its general classifiers. Has the capability to own
1585 * collaboration uses. These collaboration uses link a collaboration with the classifier to give
1586 * a
1587 * description of the workings of the classifier. Classifier is defined to be a kind of
1588 * templateable
1589 * element so that a classifier can be parameterized. It is also defined to be a kind of
1590 * parameterable
1591 * element so that a classifier can be a formal template parameter.
1592 * @return (Collection<AttributeFacade>)handleGetStaticAttributes()
1593 */
1594 public final Collection<AttributeFacade> getStaticAttributes()
1595 {
1596 Collection<AttributeFacade> getStaticAttributes7r = null;
1597 // classifierFacade has no pre constraints
1598 Collection result = handleGetStaticAttributes();
1599 List shieldedResult = this.shieldedElements(result);
1600 try
1601 {
1602 getStaticAttributes7r = (Collection<AttributeFacade>)shieldedResult;
1603 }
1604 catch (ClassCastException ex)
1605 {
1606 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1607 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getStaticAttributes Collection<AttributeFacade> " + result + ": " + shieldedResult);
1608 }
1609 // classifierFacade has no post constraints
1610 return getStaticAttributes7r;
1611 }
1612
1613 /**
1614 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
1615 * @return Collection
1616 */
1617 protected abstract Collection handleGetStaticAttributes();
1618
1619 /**
1620 * A Classifier is a classification of instances - it describes a set of instances that have
1621 * features
1622 * in common. Can specify a generalization hierarchy by referencing its general classifiers. It
1623 * may be
1624 * a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
1625 * generalization hierarchy by referencing its general classifiers. Has the capability to own
1626 * collaboration uses. These collaboration uses link a collaboration with the classifier to give
1627 * a
1628 * description of the workings of the classifier. Classifier is defined to be a kind of
1629 * templateable
1630 * element so that a classifier can be parameterized. It is also defined to be a kind of
1631 * parameterable
1632 * element so that a classifier can be a formal template parameter.
1633 * @return (Collection<AssociationEndFacade>)handleGetNavigableConnectingEnds()
1634 */
1635 public final Collection<AssociationEndFacade> getNavigableConnectingEnds()
1636 {
1637 Collection<AssociationEndFacade> getNavigableConnectingEnds8r = null;
1638 // classifierFacade has no pre constraints
1639 Collection result = handleGetNavigableConnectingEnds();
1640 List shieldedResult = this.shieldedElements(result);
1641 try
1642 {
1643 getNavigableConnectingEnds8r = (Collection<AssociationEndFacade>)shieldedResult;
1644 }
1645 catch (ClassCastException ex)
1646 {
1647 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1648 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getNavigableConnectingEnds Collection<AssociationEndFacade> " + result + ": " + shieldedResult);
1649 }
1650 // classifierFacade has no post constraints
1651 return getNavigableConnectingEnds8r;
1652 }
1653
1654 /**
1655 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
1656 * @return Collection
1657 */
1658 protected abstract Collection handleGetNavigableConnectingEnds();
1659
1660 /**
1661 * A Classifier is a classification of instances - it describes a set of instances that have
1662 * features
1663 * in common. Can specify a generalization hierarchy by referencing its general classifiers. It
1664 * may be
1665 * a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
1666 * generalization hierarchy by referencing its general classifiers. Has the capability to own
1667 * collaboration uses. These collaboration uses link a collaboration with the classifier to give
1668 * a
1669 * description of the workings of the classifier. Classifier is defined to be a kind of
1670 * templateable
1671 * element so that a classifier can be parameterized. It is also defined to be a kind of
1672 * parameterable
1673 * element so that a classifier can be a formal template parameter.
1674 * @return (List<AssociationEndFacade>)handleGetAssociationEnds()
1675 */
1676 public final List<AssociationEndFacade> getAssociationEnds()
1677 {
1678 List<AssociationEndFacade> getAssociationEnds9r = null;
1679 // classifierFacade has no pre constraints
1680 List result = handleGetAssociationEnds();
1681 List shieldedResult = this.shieldedElements(result);
1682 try
1683 {
1684 getAssociationEnds9r = (List<AssociationEndFacade>)shieldedResult;
1685 }
1686 catch (ClassCastException ex)
1687 {
1688 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1689 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getAssociationEnds List<AssociationEndFacade> " + result + ": " + shieldedResult);
1690 }
1691 // classifierFacade has no post constraints
1692 return getAssociationEnds9r;
1693 }
1694
1695 /**
1696 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
1697 * @return List
1698 */
1699 protected abstract List handleGetAssociationEnds();
1700
1701 /**
1702 * A Classifier is a classification of instances - it describes a set of instances that have
1703 * features
1704 * in common. Can specify a generalization hierarchy by referencing its general classifiers. It
1705 * may be
1706 * a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
1707 * generalization hierarchy by referencing its general classifiers. Has the capability to own
1708 * collaboration uses. These collaboration uses link a collaboration with the classifier to give
1709 * a
1710 * description of the workings of the classifier. Classifier is defined to be a kind of
1711 * templateable
1712 * element so that a classifier can be parameterized. It is also defined to be a kind of
1713 * parameterable
1714 * element so that a classifier can be a formal template parameter.
1715 * @return (Collection<AttributeFacade>)handleGetInstanceAttributes()
1716 */
1717 public final Collection<AttributeFacade> getInstanceAttributes()
1718 {
1719 Collection<AttributeFacade> getInstanceAttributes10r = null;
1720 // classifierFacade has no pre constraints
1721 Collection result = handleGetInstanceAttributes();
1722 List shieldedResult = this.shieldedElements(result);
1723 try
1724 {
1725 getInstanceAttributes10r = (Collection<AttributeFacade>)shieldedResult;
1726 }
1727 catch (ClassCastException ex)
1728 {
1729 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1730 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getInstanceAttributes Collection<AttributeFacade> " + result + ": " + shieldedResult);
1731 }
1732 // classifierFacade has no post constraints
1733 return getInstanceAttributes10r;
1734 }
1735
1736 /**
1737 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
1738 * @return Collection
1739 */
1740 protected abstract Collection handleGetInstanceAttributes();
1741
1742 private ClassifierFacade __getNonArray11r;
1743 private boolean __getNonArray11rSet = false;
1744
1745 /**
1746 * Gets the array type for this classifier. If this classifier already represents an array, it
1747 * just returns itself.
1748 * @return (ClassifierFacade)handleGetNonArray()
1749 */
1750 public final ClassifierFacade getNonArray()
1751 {
1752 ClassifierFacade getNonArray11r = this.__getNonArray11r;
1753 if (!this.__getNonArray11rSet)
1754 {
1755 // array has no pre constraints
1756 Object result = handleGetNonArray();
1757 MetafacadeBase shieldedResult = this.shieldedElement(result);
1758 try
1759 {
1760 getNonArray11r = (ClassifierFacade)shieldedResult;
1761 }
1762 catch (ClassCastException ex)
1763 {
1764 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1765 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getNonArray ClassifierFacade " + result + ": " + shieldedResult);
1766 }
1767 // array has no post constraints
1768 this.__getNonArray11r = getNonArray11r;
1769 if (isMetafacadePropertyCachingEnabled())
1770 {
1771 this.__getNonArray11rSet = true;
1772 }
1773 }
1774 return getNonArray11r;
1775 }
1776
1777 /**
1778 * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
1779 * @return Object
1780 */
1781 protected abstract Object handleGetNonArray();
1782
1783 /**
1784 * Lists the classes associated to this one, there is no repitition of classes. The order of the
1785 * elements is predictable.
1786 * @return (Collection<ClassifierFacade>)handleGetAllAssociatedClasses()
1787 */
1788 public final Collection<ClassifierFacade> getAllAssociatedClasses()
1789 {
1790 Collection<ClassifierFacade> getAllAssociatedClasses12r = null;
1791 // associatedClasses has no pre constraints
1792 Collection result = handleGetAllAssociatedClasses();
1793 List shieldedResult = this.shieldedElements(result);
1794 try
1795 {
1796 getAllAssociatedClasses12r = (Collection<ClassifierFacade>)shieldedResult;
1797 }
1798 catch (ClassCastException ex)
1799 {
1800 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1801 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getAllAssociatedClasses Collection<ClassifierFacade> " + result + ": " + shieldedResult);
1802 }
1803 // associatedClasses has no post constraints
1804 return getAllAssociatedClasses12r;
1805 }
1806
1807 /**
1808 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
1809 * @return Collection
1810 */
1811 protected abstract Collection handleGetAllAssociatedClasses();
1812
1813 /**
1814 * Lists all classes associated to this one and any ancestor classes (through generalization).
1815 * There will be no duplicates. The order of the elements is predictable.
1816 * @return (Collection<ClassifierFacade>)handleGetAssociatedClasses()
1817 */
1818 public final Collection<ClassifierFacade> getAssociatedClasses()
1819 {
1820 Collection<ClassifierFacade> getAssociatedClasses13r = null;
1821 // allAssociatedClasses has no pre constraints
1822 Collection result = handleGetAssociatedClasses();
1823 List shieldedResult = this.shieldedElements(result);
1824 try
1825 {
1826 getAssociatedClasses13r = (Collection<ClassifierFacade>)shieldedResult;
1827 }
1828 catch (ClassCastException ex)
1829 {
1830 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1831 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getAssociatedClasses Collection<ClassifierFacade> " + result + ": " + shieldedResult);
1832 }
1833 // allAssociatedClasses has no post constraints
1834 return getAssociatedClasses13r;
1835 }
1836
1837 /**
1838 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
1839 * @return Collection
1840 */
1841 protected abstract Collection handleGetAssociatedClasses();
1842
1843 private Collection<ClassifierFacade> __getInterfaceAbstractions14r;
1844 private boolean __getInterfaceAbstractions14rSet = false;
1845
1846 /**
1847 * A Classifier is a classification of instances - it describes a set of instances that have
1848 * features
1849 * in common. Can specify a generalization hierarchy by referencing its general classifiers. It
1850 * may be
1851 * a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
1852 * generalization hierarchy by referencing its general classifiers. Has the capability to own
1853 * collaboration uses. These collaboration uses link a collaboration with the classifier to give
1854 * a
1855 * description of the workings of the classifier. Classifier is defined to be a kind of
1856 * templateable
1857 * element so that a classifier can be parameterized. It is also defined to be a kind of
1858 * parameterable
1859 * element so that a classifier can be a formal template parameter.
1860 * @return (Collection<ClassifierFacade>)handleGetInterfaceAbstractions()
1861 */
1862 public final Collection<ClassifierFacade> getInterfaceAbstractions()
1863 {
1864 Collection<ClassifierFacade> getInterfaceAbstractions14r = this.__getInterfaceAbstractions14r;
1865 if (!this.__getInterfaceAbstractions14rSet)
1866 {
1867 // classifierFacade has no pre constraints
1868 Collection result = handleGetInterfaceAbstractions();
1869 List shieldedResult = this.shieldedElements(result);
1870 try
1871 {
1872 getInterfaceAbstractions14r = (Collection<ClassifierFacade>)shieldedResult;
1873 }
1874 catch (ClassCastException ex)
1875 {
1876 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1877 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getInterfaceAbstractions Collection<ClassifierFacade> " + result + ": " + shieldedResult);
1878 }
1879 // classifierFacade has no post constraints
1880 this.__getInterfaceAbstractions14r = getInterfaceAbstractions14r;
1881 if (isMetafacadePropertyCachingEnabled())
1882 {
1883 this.__getInterfaceAbstractions14rSet = true;
1884 }
1885 }
1886 return getInterfaceAbstractions14r;
1887 }
1888
1889 /**
1890 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
1891 * @return Collection
1892 */
1893 protected abstract Collection handleGetInterfaceAbstractions();
1894
1895 private ClassifierFacade __getSuperClass15r;
1896 private boolean __getSuperClass15rSet = false;
1897
1898 /**
1899 * A Classifier is a classification of instances - it describes a set of instances that have
1900 * features
1901 * in common. Can specify a generalization hierarchy by referencing its general classifiers. It
1902 * may be
1903 * a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
1904 * generalization hierarchy by referencing its general classifiers. Has the capability to own
1905 * collaboration uses. These collaboration uses link a collaboration with the classifier to give
1906 * a
1907 * description of the workings of the classifier. Classifier is defined to be a kind of
1908 * templateable
1909 * element so that a classifier can be parameterized. It is also defined to be a kind of
1910 * parameterable
1911 * element so that a classifier can be a formal template parameter.
1912 * @return (ClassifierFacade)handleGetSuperClass()
1913 */
1914 public final ClassifierFacade getSuperClass()
1915 {
1916 ClassifierFacade getSuperClass15r = this.__getSuperClass15r;
1917 if (!this.__getSuperClass15rSet)
1918 {
1919 // classifierFacade has no pre constraints
1920 Object result = handleGetSuperClass();
1921 MetafacadeBase shieldedResult = this.shieldedElement(result);
1922 try
1923 {
1924 getSuperClass15r = (ClassifierFacade)shieldedResult;
1925 }
1926 catch (ClassCastException ex)
1927 {
1928 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1929 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getSuperClass ClassifierFacade " + result + ": " + shieldedResult);
1930 }
1931 // classifierFacade has no post constraints
1932 this.__getSuperClass15r = getSuperClass15r;
1933 if (isMetafacadePropertyCachingEnabled())
1934 {
1935 this.__getSuperClass15rSet = true;
1936 }
1937 }
1938 return getSuperClass15r;
1939 }
1940
1941 /**
1942 * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
1943 * @return Object
1944 */
1945 protected abstract Object handleGetSuperClass();
1946
1947 private Collection<OperationFacade> __getImplementationOperations16r;
1948 private boolean __getImplementationOperations16rSet = false;
1949
1950 /**
1951 * A Classifier is a classification of instances - it describes a set of instances that have
1952 * features
1953 * in common. Can specify a generalization hierarchy by referencing its general classifiers. It
1954 * may be
1955 * a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
1956 * generalization hierarchy by referencing its general classifiers. Has the capability to own
1957 * collaboration uses. These collaboration uses link a collaboration with the classifier to give
1958 * a
1959 * description of the workings of the classifier. Classifier is defined to be a kind of
1960 * templateable
1961 * element so that a classifier can be parameterized. It is also defined to be a kind of
1962 * parameterable
1963 * element so that a classifier can be a formal template parameter.
1964 * @return (Collection<OperationFacade>)handleGetImplementationOperations()
1965 */
1966 public final Collection<OperationFacade> getImplementationOperations()
1967 {
1968 Collection<OperationFacade> getImplementationOperations16r = this.__getImplementationOperations16r;
1969 if (!this.__getImplementationOperations16rSet)
1970 {
1971 // classifierFacade has no pre constraints
1972 Collection result = handleGetImplementationOperations();
1973 List shieldedResult = this.shieldedElements(result);
1974 try
1975 {
1976 getImplementationOperations16r = (Collection<OperationFacade>)shieldedResult;
1977 }
1978 catch (ClassCastException ex)
1979 {
1980 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
1981 ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getImplementationOperations Collection<OperationFacade> " + result + ": " + shieldedResult);
1982 }
1983 // classifierFacade has no post constraints
1984 this.__getImplementationOperations16r = getImplementationOperations16r;
1985 if (isMetafacadePropertyCachingEnabled())
1986 {
1987 this.__getImplementationOperations16rSet = true;
1988 }
1989 }
1990 return getImplementationOperations16r;
1991 }
1992
1993 /**
1994 * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
1995 * @return Collection
1996 */
1997 protected abstract Collection handleGetImplementationOperations();
1998
1999 /**
2000 * <p><b>Constraint:</b> org::andromda::metafacades::uml::ClassifierFacade::classifier must have a name</p>
2001 * <p><b>Error:</b> Each classifier must have a non-empty name.</p>
2002 * <p><b>OCL:</b> context ClassifierFacade inv: name->notEmpty()</p>
2003 * <p><b>Constraint:</b> org::andromda::metafacades::uml::ClassifierFacade::attribute names must be unique</p>
2004 * <p><b>Error:</b> Each attribute on an element must have a unique name.</p>
2005 * <p><b>OCL:</b> context ClassifierFacade
2006 inv : attributes -> isUnique(name)</p>
2007 * <p><b>Constraint:</b> org::andromda::metafacades::uml::ClassifierFacade::association end names must be unique</p>
2008 * <p><b>Error:</b> The name of each navigable connecting association end must be unique.</p>
2009 * <p><b>OCL:</b> context ClassifierFacade
2010 inv : navigableConnectingEnds -> isUnique(name)</p>
2011 * <p><b>Constraint:</b> org::andromda::metafacades::uml::ClassifierFacade::source dependencies must be unique</p>
2012 * <p><b>Error:</b> Each dependency going out a of an element must have a unique name.</p>
2013 * <p><b>OCL:</b> context ClassifierFacade
2014 inv : sourceDependencies -> isUnique(name)</p>
2015 * @param validationMessages Collection<ModelValidationMessage>
2016 * @see GeneralizableElementFacadeLogicImpl#validateInvariants(Collection validationMessages)
2017 */
2018 @Override
2019 public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
2020 {
2021 super.validateInvariants(validationMessages);
2022 try
2023 {
2024 final Object contextElement = this.THIS();
2025 boolean constraintValid = OCLResultEnsurer.ensure(OCLCollections.notEmpty(OCLIntrospector.invoke(contextElement,"name")));
2026 if (!constraintValid)
2027 {
2028 validationMessages.add(
2029 new ModelValidationMessage(
2030 (MetafacadeBase)contextElement ,
2031 "org::andromda::metafacades::uml::ClassifierFacade::classifier must have a name",
2032 "Each classifier must have a non-empty name."));
2033 }
2034 }
2035 catch (Throwable th)
2036 {
2037 Throwable cause = th.getCause();
2038 int depth = 0; // Some throwables have infinite recursion
2039 while (cause != null && depth < 7)
2040 {
2041 th = cause;
2042 depth++;
2043 }
2044 logger.error("Error validating constraint 'org::andromda::metafacades::uml::ClassifierFacade::classifier must have a name' ON "
2045 + this.THIS().toString() + ": " + th.getMessage(), th);
2046 }
2047 try
2048 {
2049 final Object contextElement = this.THIS();
2050 boolean constraintValid = OCLResultEnsurer.ensure(OCLCollections.isUnique(OCLIntrospector.invoke(contextElement,"attributes"),new Transformer(){public Object transform(Object object){return OCLIntrospector.invoke(object,"name");}}));
2051 if (!constraintValid)
2052 {
2053 validationMessages.add(
2054 new ModelValidationMessage(
2055 (MetafacadeBase)contextElement ,
2056 "org::andromda::metafacades::uml::ClassifierFacade::attribute names must be unique",
2057 "Each attribute on an element must have a unique name."));
2058 }
2059 }
2060 catch (Throwable th)
2061 {
2062 Throwable cause = th.getCause();
2063 int depth = 0; // Some throwables have infinite recursion
2064 while (cause != null && depth < 7)
2065 {
2066 th = cause;
2067 depth++;
2068 }
2069 logger.error("Error validating constraint 'org::andromda::metafacades::uml::ClassifierFacade::attribute names must be unique' ON "
2070 + this.THIS().toString() + ": " + th.getMessage(), th);
2071 }
2072 try
2073 {
2074 final Object contextElement = this.THIS();
2075 boolean constraintValid = OCLResultEnsurer.ensure(OCLCollections.isUnique(OCLIntrospector.invoke(contextElement,"navigableConnectingEnds"),new Transformer(){public Object transform(Object object){return OCLIntrospector.invoke(object,"name");}}));
2076 if (!constraintValid)
2077 {
2078 validationMessages.add(
2079 new ModelValidationMessage(
2080 (MetafacadeBase)contextElement ,
2081 "org::andromda::metafacades::uml::ClassifierFacade::association end names must be unique",
2082 "The name of each navigable connecting association end must be unique."));
2083 }
2084 }
2085 catch (Throwable th)
2086 {
2087 Throwable cause = th.getCause();
2088 int depth = 0; // Some throwables have infinite recursion
2089 while (cause != null && depth < 7)
2090 {
2091 th = cause;
2092 depth++;
2093 }
2094 logger.error("Error validating constraint 'org::andromda::metafacades::uml::ClassifierFacade::association end names must be unique' ON "
2095 + this.THIS().toString() + ": " + th.getMessage(), th);
2096 }
2097 try
2098 {
2099 final Object contextElement = this.THIS();
2100 boolean constraintValid = OCLResultEnsurer.ensure(OCLCollections.isUnique(OCLIntrospector.invoke(contextElement,"sourceDependencies"),new Transformer(){public Object transform(Object object){return OCLIntrospector.invoke(object,"name");}}));
2101 if (!constraintValid)
2102 {
2103 validationMessages.add(
2104 new ModelValidationMessage(
2105 (MetafacadeBase)contextElement ,
2106 "org::andromda::metafacades::uml::ClassifierFacade::source dependencies must be unique",
2107 "Each dependency going out a of an element must have a unique name."));
2108 }
2109 }
2110 catch (Throwable th)
2111 {
2112 Throwable cause = th.getCause();
2113 int depth = 0; // Some throwables have infinite recursion
2114 while (cause != null && depth < 7)
2115 {
2116 th = cause;
2117 depth++;
2118 }
2119 logger.error("Error validating constraint 'org::andromda::metafacades::uml::ClassifierFacade::source dependencies must be unique' ON "
2120 + this.THIS().toString() + ": " + th.getMessage(), th);
2121 }
2122 }
2123 }