1 // license-header java merge-point
2 //
3 // Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
4 //
5 package org.andromda.cartridges.jsf2.metafacades;
6
7 import java.util.Collection;
8 import org.andromda.core.common.Introspector;
9 import org.andromda.core.metafacade.MetafacadeBase;
10 import org.andromda.core.metafacade.MetafacadeFactory;
11 import org.andromda.core.metafacade.ModelValidationMessage;
12 import org.andromda.metafacades.uml.AttributeFacade;
13 import org.andromda.metafacades.uml.ClassifierFacade;
14 import org.andromda.metafacades.uml.ConstraintFacade;
15 import org.andromda.metafacades.uml.DependencyFacade;
16 import org.andromda.metafacades.uml.EnumerationFacade;
17 import org.andromda.metafacades.uml.FrontEndParameter;
18 import org.andromda.metafacades.uml.ModelElementFacade;
19 import org.andromda.metafacades.uml.ModelFacade;
20 import org.andromda.metafacades.uml.PackageFacade;
21 import org.andromda.metafacades.uml.ParameterFacade;
22 import org.andromda.metafacades.uml.StateMachineFacade;
23 import org.andromda.metafacades.uml.StereotypeFacade;
24 import org.andromda.metafacades.uml.TaggedValueFacade;
25 import org.andromda.metafacades.uml.TemplateParameterFacade;
26 import org.andromda.metafacades.uml.TypeMappings;
27
28 /**
29 * Represents an attribute on a classifier used by a JSF application.
30 * MetafacadeLogic for JSFAttribute
31 *
32 * @see JSFAttribute
33 */
34 public abstract class JSFAttributeLogic
35 extends MetafacadeBase
36 implements JSFAttribute
37 {
38 /**
39 * The underlying UML object
40 * @see Object
41 */
42 protected Object metaObject;
43
44 /** Create Metafacade implementation instance using the MetafacadeFactory from the context
45 * @param metaObjectIn
46 * @param context
47 */
48 protected JSFAttributeLogic(Object metaObjectIn, String context)
49 {
50 super(metaObjectIn, getContext(context));
51 this.superAttributeFacade =
52 (AttributeFacade)
53 MetafacadeFactory.getInstance().createFacadeImpl(
54 "org.andromda.metafacades.uml.AttributeFacade",
55 metaObjectIn,
56 getContext(context));
57 this.metaObject = metaObjectIn;
58 }
59
60 /**
61 * Gets the context for this metafacade logic instance.
62 * @param context String. Set to JSFAttribute if null
63 * @return context String
64 */
65 private static String getContext(String context)
66 {
67 if (context == null)
68 {
69 context = "org.andromda.cartridges.jsf2.metafacades.JSFAttribute";
70 }
71 return context;
72 }
73
74 private AttributeFacade superAttributeFacade;
75 private boolean superAttributeFacadeInitialized = false;
76
77 /**
78 * Gets the AttributeFacade parent instance.
79 * @return this.superAttributeFacade AttributeFacade
80 */
81 private AttributeFacade getSuperAttributeFacade()
82 {
83 if (!this.superAttributeFacadeInitialized)
84 {
85 ((MetafacadeBase)this.superAttributeFacade).setMetafacadeContext(this.getMetafacadeContext());
86 this.superAttributeFacadeInitialized = true;
87 }
88 return this.superAttributeFacade;
89 }
90
91 /** Reset context only for non-root metafacades
92 * @param context
93 * @see org.andromda.core.metafacade.MetafacadeBase#resetMetafacadeContext(String context)
94 */
95 @Override
96 public void resetMetafacadeContext(String context)
97 {
98 if (!this.contextRoot) // reset context only for non-root metafacades
99 {
100 context = getContext(context); // to have same value as in original constructor call
101 setMetafacadeContext (context);
102 if (this.superAttributeFacadeInitialized)
103 {
104 ((MetafacadeBase)this.superAttributeFacade).resetMetafacadeContext(context);
105 }
106 }
107 }
108
109 /**
110 * @return boolean true always
111 * @see JSFAttribute
112 */
113 public boolean isJSFAttributeMetaType()
114 {
115 return true;
116 }
117
118 // --------------- attributes ---------------------
119
120 /**
121 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getMessageKey()
122 * @return String
123 */
124 protected abstract String handleGetMessageKey();
125
126 private String __messageKey1a;
127 private boolean __messageKey1aSet = false;
128
129 /**
130 * The message key for this attribute.
131 * @return (String)handleGetMessageKey()
132 */
133 public final String getMessageKey()
134 {
135 String messageKey1a = this.__messageKey1a;
136 if (!this.__messageKey1aSet)
137 {
138 // messageKey has no pre constraints
139 messageKey1a = handleGetMessageKey();
140 // messageKey has no post constraints
141 this.__messageKey1a = messageKey1a;
142 if (isMetafacadePropertyCachingEnabled())
143 {
144 this.__messageKey1aSet = true;
145 }
146 }
147 return messageKey1a;
148 }
149
150 /**
151 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getMessageValue()
152 * @return String
153 */
154 protected abstract String handleGetMessageValue();
155
156 private String __messageValue2a;
157 private boolean __messageValue2aSet = false;
158
159 /**
160 * The default value for the message key.
161 * @return (String)handleGetMessageValue()
162 */
163 public final String getMessageValue()
164 {
165 String messageValue2a = this.__messageValue2a;
166 if (!this.__messageValue2aSet)
167 {
168 // messageValue has no pre constraints
169 messageValue2a = handleGetMessageValue();
170 // messageValue has no post constraints
171 this.__messageValue2a = messageValue2a;
172 if (isMetafacadePropertyCachingEnabled())
173 {
174 this.__messageValue2aSet = true;
175 }
176 }
177 return messageValue2a;
178 }
179
180 /**
181 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getDummyValue()
182 * @return String
183 */
184 protected abstract String handleGetDummyValue();
185
186 private String __dummyValue3a;
187 private boolean __dummyValue3aSet = false;
188
189 /**
190 * The dummy value to give the attribute when creating a dummy instance of this attribute's
191 * owner.
192 * @return (String)handleGetDummyValue()
193 */
194 public final String getDummyValue()
195 {
196 String dummyValue3a = this.__dummyValue3a;
197 if (!this.__dummyValue3aSet)
198 {
199 // dummyValue has no pre constraints
200 dummyValue3a = handleGetDummyValue();
201 // dummyValue has no post constraints
202 this.__dummyValue3a = dummyValue3a;
203 if (isMetafacadePropertyCachingEnabled())
204 {
205 this.__dummyValue3aSet = true;
206 }
207 }
208 return dummyValue3a;
209 }
210
211 /**
212 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getFormat()
213 * @return String
214 */
215 protected abstract String handleGetFormat();
216
217 private String __format4a;
218 private boolean __format4aSet = false;
219
220 /**
221 * If this attributes represents a date or time this method will return the format in which it
222 * must be represented. In the event this format has not been specified by the any tagged value
223 * the default will be used.
224 * @return (String)handleGetFormat()
225 */
226 public final String getFormat()
227 {
228 String format4a = this.__format4a;
229 if (!this.__format4aSet)
230 {
231 // format has no pre constraints
232 format4a = handleGetFormat();
233 // format has no post constraints
234 this.__format4a = format4a;
235 if (isMetafacadePropertyCachingEnabled())
236 {
237 this.__format4aSet = true;
238 }
239 }
240 return format4a;
241 }
242
243 /**
244 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputTextarea()
245 * @return boolean
246 */
247 protected abstract boolean handleIsInputTextarea();
248
249 private boolean __inputTextarea5a;
250 private boolean __inputTextarea5aSet = false;
251
252 /**
253 * Indicates if this parameter represents as an input text area widget.
254 * @return (boolean)handleIsInputTextarea()
255 */
256 public final boolean isInputTextarea()
257 {
258 boolean inputTextarea5a = this.__inputTextarea5a;
259 if (!this.__inputTextarea5aSet)
260 {
261 // inputTextarea has no pre constraints
262 inputTextarea5a = handleIsInputTextarea();
263 // inputTextarea has no post constraints
264 this.__inputTextarea5a = inputTextarea5a;
265 if (isMetafacadePropertyCachingEnabled())
266 {
267 this.__inputTextarea5aSet = true;
268 }
269 }
270 return inputTextarea5a;
271 }
272
273 /**
274 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputText()
275 * @return boolean
276 */
277 protected abstract boolean handleIsInputText();
278
279 private boolean __inputText6a;
280 private boolean __inputText6aSet = false;
281
282 /**
283 * Indicates whether or not this parameter should be rendered as a text input widget.
284 * @return (boolean)handleIsInputText()
285 */
286 public final boolean isInputText()
287 {
288 boolean inputText6a = this.__inputText6a;
289 if (!this.__inputText6aSet)
290 {
291 // inputText has no pre constraints
292 inputText6a = handleIsInputText();
293 // inputText has no post constraints
294 this.__inputText6a = inputText6a;
295 if (isMetafacadePropertyCachingEnabled())
296 {
297 this.__inputText6aSet = true;
298 }
299 }
300 return inputText6a;
301 }
302
303 /**
304 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputSecret()
305 * @return boolean
306 */
307 protected abstract boolean handleIsInputSecret();
308
309 private boolean __inputSecret7a;
310 private boolean __inputSecret7aSet = false;
311
312 /**
313 * Indicates whether or not this parameter represents an input "secret" widget (i.e. password).
314 * @return (boolean)handleIsInputSecret()
315 */
316 public final boolean isInputSecret()
317 {
318 boolean inputSecret7a = this.__inputSecret7a;
319 if (!this.__inputSecret7aSet)
320 {
321 // inputSecret has no pre constraints
322 inputSecret7a = handleIsInputSecret();
323 // inputSecret has no post constraints
324 this.__inputSecret7a = inputSecret7a;
325 if (isMetafacadePropertyCachingEnabled())
326 {
327 this.__inputSecret7aSet = true;
328 }
329 }
330 return inputSecret7a;
331 }
332
333 /**
334 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputSelect()
335 * @return boolean
336 */
337 protected abstract boolean handleIsInputSelect();
338
339 private boolean __inputSelect8a;
340 private boolean __inputSelect8aSet = false;
341
342 /**
343 * Indicates whether or not this parameter represents an input select widget.
344 * @return (boolean)handleIsInputSelect()
345 */
346 public final boolean isInputSelect()
347 {
348 boolean inputSelect8a = this.__inputSelect8a;
349 if (!this.__inputSelect8aSet)
350 {
351 // inputSelect has no pre constraints
352 inputSelect8a = handleIsInputSelect();
353 // inputSelect has no post constraints
354 this.__inputSelect8a = inputSelect8a;
355 if (isMetafacadePropertyCachingEnabled())
356 {
357 this.__inputSelect8aSet = true;
358 }
359 }
360 return inputSelect8a;
361 }
362
363 /**
364 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputRadio()
365 * @return boolean
366 */
367 protected abstract boolean handleIsInputRadio();
368
369 private boolean __inputRadio9a;
370 private boolean __inputRadio9aSet = false;
371
372 /**
373 * Indicates whether or not this parameter should be rendered as an input radio widget.
374 * @return (boolean)handleIsInputRadio()
375 */
376 public final boolean isInputRadio()
377 {
378 boolean inputRadio9a = this.__inputRadio9a;
379 if (!this.__inputRadio9aSet)
380 {
381 // inputRadio has no pre constraints
382 inputRadio9a = handleIsInputRadio();
383 // inputRadio has no post constraints
384 this.__inputRadio9a = inputRadio9a;
385 if (isMetafacadePropertyCachingEnabled())
386 {
387 this.__inputRadio9aSet = true;
388 }
389 }
390 return inputRadio9a;
391 }
392
393 /**
394 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputMultibox()
395 * @return boolean
396 */
397 protected abstract boolean handleIsInputMultibox();
398
399 private boolean __inputMultibox10a;
400 private boolean __inputMultibox10aSet = false;
401
402 /**
403 * Indicates whether or not this type represents an input multibox.
404 * @return (boolean)handleIsInputMultibox()
405 */
406 public final boolean isInputMultibox()
407 {
408 boolean inputMultibox10a = this.__inputMultibox10a;
409 if (!this.__inputMultibox10aSet)
410 {
411 // inputMultibox has no pre constraints
412 inputMultibox10a = handleIsInputMultibox();
413 // inputMultibox has no post constraints
414 this.__inputMultibox10a = inputMultibox10a;
415 if (isMetafacadePropertyCachingEnabled())
416 {
417 this.__inputMultibox10aSet = true;
418 }
419 }
420 return inputMultibox10a;
421 }
422
423 /**
424 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputHidden()
425 * @return boolean
426 */
427 protected abstract boolean handleIsInputHidden();
428
429 private boolean __inputHidden11a;
430 private boolean __inputHidden11aSet = false;
431
432 /**
433 * Indicates whether or not this parameter represents a hidden input widget.
434 * @return (boolean)handleIsInputHidden()
435 */
436 public final boolean isInputHidden()
437 {
438 boolean inputHidden11a = this.__inputHidden11a;
439 if (!this.__inputHidden11aSet)
440 {
441 // inputHidden has no pre constraints
442 inputHidden11a = handleIsInputHidden();
443 // inputHidden has no post constraints
444 this.__inputHidden11a = inputHidden11a;
445 if (isMetafacadePropertyCachingEnabled())
446 {
447 this.__inputHidden11aSet = true;
448 }
449 }
450 return inputHidden11a;
451 }
452
453 /**
454 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputFile()
455 * @return boolean
456 */
457 protected abstract boolean handleIsInputFile();
458
459 private boolean __inputFile12a;
460 private boolean __inputFile12aSet = false;
461
462 /**
463 * Indicates whether or not this is a file input type.
464 * @return (boolean)handleIsInputFile()
465 */
466 public final boolean isInputFile()
467 {
468 boolean inputFile12a = this.__inputFile12a;
469 if (!this.__inputFile12aSet)
470 {
471 // inputFile has no pre constraints
472 inputFile12a = handleIsInputFile();
473 // inputFile has no post constraints
474 this.__inputFile12a = inputFile12a;
475 if (isMetafacadePropertyCachingEnabled())
476 {
477 this.__inputFile12aSet = true;
478 }
479 }
480 return inputFile12a;
481 }
482
483 /**
484 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputCheckbox()
485 * @return boolean
486 */
487 protected abstract boolean handleIsInputCheckbox();
488
489 private boolean __inputCheckbox13a;
490 private boolean __inputCheckbox13aSet = false;
491
492 /**
493 * Indicates if this parameter represents a checkbox widget.
494 * @return (boolean)handleIsInputCheckbox()
495 */
496 public final boolean isInputCheckbox()
497 {
498 boolean inputCheckbox13a = this.__inputCheckbox13a;
499 if (!this.__inputCheckbox13aSet)
500 {
501 // inputCheckbox has no pre constraints
502 inputCheckbox13a = handleIsInputCheckbox();
503 // inputCheckbox has no post constraints
504 this.__inputCheckbox13a = inputCheckbox13a;
505 if (isMetafacadePropertyCachingEnabled())
506 {
507 this.__inputCheckbox13aSet = true;
508 }
509 }
510 return inputCheckbox13a;
511 }
512
513 /**
514 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getValueListDummyValue()
515 * @return String
516 */
517 protected abstract String handleGetValueListDummyValue();
518
519 private String __valueListDummyValue14a;
520 private boolean __valueListDummyValue14aSet = false;
521
522 /**
523 * The dummy value for a value list.
524 * @return (String)handleGetValueListDummyValue()
525 */
526 public final String getValueListDummyValue()
527 {
528 String valueListDummyValue14a = this.__valueListDummyValue14a;
529 if (!this.__valueListDummyValue14aSet)
530 {
531 // valueListDummyValue has no pre constraints
532 valueListDummyValue14a = handleGetValueListDummyValue();
533 // valueListDummyValue has no post constraints
534 this.__valueListDummyValue14a = valueListDummyValue14a;
535 if (isMetafacadePropertyCachingEnabled())
536 {
537 this.__valueListDummyValue14aSet = true;
538 }
539 }
540 return valueListDummyValue14a;
541 }
542
543 /**
544 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getValidWhen()
545 * @return String
546 */
547 protected abstract String handleGetValidWhen();
548
549 private String __validWhen15a;
550 private boolean __validWhen15aSet = false;
551
552 /**
553 * The validator's 'validwhen' value, this is useful when the validation of a parameter depends
554 * on the validation of others. See the apache commons-validator documentation for more
555 * information.
556 * @return (String)handleGetValidWhen()
557 */
558 public final String getValidWhen()
559 {
560 String validWhen15a = this.__validWhen15a;
561 if (!this.__validWhen15aSet)
562 {
563 // validWhen has no pre constraints
564 validWhen15a = handleGetValidWhen();
565 // validWhen has no post constraints
566 this.__validWhen15a = validWhen15a;
567 if (isMetafacadePropertyCachingEnabled())
568 {
569 this.__validWhen15aSet = true;
570 }
571 }
572 return validWhen15a;
573 }
574
575 /**
576 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getValidatorTypes()
577 * @return Collection
578 */
579 protected abstract Collection handleGetValidatorTypes();
580
581 private Collection __validatorTypes16a;
582 private boolean __validatorTypes16aSet = false;
583
584 /**
585 * All validator types for this attribute.
586 * @return (Collection)handleGetValidatorTypes()
587 */
588 public final Collection getValidatorTypes()
589 {
590 Collection validatorTypes16a = this.__validatorTypes16a;
591 if (!this.__validatorTypes16aSet)
592 {
593 // validatorTypes has no pre constraints
594 validatorTypes16a = handleGetValidatorTypes();
595 // validatorTypes has no post constraints
596 this.__validatorTypes16a = validatorTypes16a;
597 if (isMetafacadePropertyCachingEnabled())
598 {
599 this.__validatorTypes16aSet = true;
600 }
601 }
602 return validatorTypes16a;
603 }
604
605 /**
606 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isValidationRequired()
607 * @return boolean
608 */
609 protected abstract boolean handleIsValidationRequired();
610
611 private boolean __validationRequired17a;
612 private boolean __validationRequired17aSet = false;
613
614 /**
615 * Indicates whether or not this attribute requires some kind of validation (the collection of
616 * validator types is not empty).
617 * @return (boolean)handleIsValidationRequired()
618 */
619 public final boolean isValidationRequired()
620 {
621 boolean validationRequired17a = this.__validationRequired17a;
622 if (!this.__validationRequired17aSet)
623 {
624 // validationRequired has no pre constraints
625 validationRequired17a = handleIsValidationRequired();
626 // validationRequired has no post constraints
627 this.__validationRequired17a = validationRequired17a;
628 if (isMetafacadePropertyCachingEnabled())
629 {
630 this.__validationRequired17aSet = true;
631 }
632 }
633 return validationRequired17a;
634 }
635
636 /**
637 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isStrictDateFormat()
638 * @return boolean
639 */
640 protected abstract boolean handleIsStrictDateFormat();
641
642 private boolean __strictDateFormat18a;
643 private boolean __strictDateFormat18aSet = false;
644
645 /**
646 * Indicates where or not the date format is to be strictly respected. Otherwise the date
647 * formatter used for the representation of this date is to be set to lenient.
648 * @return (boolean)handleIsStrictDateFormat()
649 */
650 public final boolean isStrictDateFormat()
651 {
652 boolean strictDateFormat18a = this.__strictDateFormat18a;
653 if (!this.__strictDateFormat18aSet)
654 {
655 // strictDateFormat has no pre constraints
656 strictDateFormat18a = handleIsStrictDateFormat();
657 // strictDateFormat has no post constraints
658 this.__strictDateFormat18a = strictDateFormat18a;
659 if (isMetafacadePropertyCachingEnabled())
660 {
661 this.__strictDateFormat18aSet = true;
662 }
663 }
664 return strictDateFormat18a;
665 }
666
667 /**
668 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isEqualValidator()
669 * @return boolean
670 */
671 protected abstract boolean handleIsEqualValidator();
672
673 private boolean __equalValidator19a;
674 private boolean __equalValidator19aSet = false;
675
676 /**
677 * Indicates whether or not this parameter uses the equal validator.
678 * @return (boolean)handleIsEqualValidator()
679 */
680 public final boolean isEqualValidator()
681 {
682 boolean equalValidator19a = this.__equalValidator19a;
683 if (!this.__equalValidator19aSet)
684 {
685 // equalValidator has no pre constraints
686 equalValidator19a = handleIsEqualValidator();
687 // equalValidator has no post constraints
688 this.__equalValidator19a = equalValidator19a;
689 if (isMetafacadePropertyCachingEnabled())
690 {
691 this.__equalValidator19aSet = true;
692 }
693 }
694 return equalValidator19a;
695 }
696
697 /**
698 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputTable()
699 * @return boolean
700 */
701 protected abstract boolean handleIsInputTable();
702
703 private boolean __inputTable20a;
704 private boolean __inputTable20aSet = false;
705
706 /**
707 * Indicates whether or not this is an table input type.
708 * @return (boolean)handleIsInputTable()
709 */
710 public final boolean isInputTable()
711 {
712 boolean inputTable20a = this.__inputTable20a;
713 if (!this.__inputTable20aSet)
714 {
715 // inputTable has no pre constraints
716 inputTable20a = handleIsInputTable();
717 // inputTable has no post constraints
718 this.__inputTable20a = inputTable20a;
719 if (isMetafacadePropertyCachingEnabled())
720 {
721 this.__inputTable20aSet = true;
722 }
723 }
724 return inputTable20a;
725 }
726
727 /**
728 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isInputTypePresent()
729 * @return boolean
730 */
731 protected abstract boolean handleIsInputTypePresent();
732
733 private boolean __inputTypePresent21a;
734 private boolean __inputTypePresent21aSet = false;
735
736 /**
737 * Indicates whether or not there is an input type defined for this attribute.
738 * @return (boolean)handleIsInputTypePresent()
739 */
740 public final boolean isInputTypePresent()
741 {
742 boolean inputTypePresent21a = this.__inputTypePresent21a;
743 if (!this.__inputTypePresent21aSet)
744 {
745 // inputTypePresent has no pre constraints
746 inputTypePresent21a = handleIsInputTypePresent();
747 // inputTypePresent has no post constraints
748 this.__inputTypePresent21a = inputTypePresent21a;
749 if (isMetafacadePropertyCachingEnabled())
750 {
751 this.__inputTypePresent21aSet = true;
752 }
753 }
754 return inputTypePresent21a;
755 }
756
757 /**
758 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#isPlaintext()
759 * @return boolean
760 */
761 protected abstract boolean handleIsPlaintext();
762
763 private boolean __plaintext22a;
764 private boolean __plaintext22aSet = false;
765
766 /**
767 * Indicates whether or not this attribute's value should be rendered as plain text (not as a
768 * widget).
769 * @return (boolean)handleIsPlaintext()
770 */
771 public final boolean isPlaintext()
772 {
773 boolean plaintext22a = this.__plaintext22a;
774 if (!this.__plaintext22aSet)
775 {
776 // plaintext has no pre constraints
777 plaintext22a = handleIsPlaintext();
778 // plaintext has no post constraints
779 this.__plaintext22a = plaintext22a;
780 if (isMetafacadePropertyCachingEnabled())
781 {
782 this.__plaintext22aSet = true;
783 }
784 }
785 return plaintext22a;
786 }
787
788 /**
789 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getInputTableIdentifierColumns()
790 * @return String
791 */
792 protected abstract String handleGetInputTableIdentifierColumns();
793
794 private String __inputTableIdentifierColumns23a;
795 private boolean __inputTableIdentifierColumns23aSet = false;
796
797 /**
798 * A comma separated list of the input table identifier columns (these are the columns that
799 * uniquely define a row in an input table).
800 * @return (String)handleGetInputTableIdentifierColumns()
801 */
802 public final String getInputTableIdentifierColumns()
803 {
804 String inputTableIdentifierColumns23a = this.__inputTableIdentifierColumns23a;
805 if (!this.__inputTableIdentifierColumns23aSet)
806 {
807 // inputTableIdentifierColumns has no pre constraints
808 inputTableIdentifierColumns23a = handleGetInputTableIdentifierColumns();
809 // inputTableIdentifierColumns has no post constraints
810 this.__inputTableIdentifierColumns23a = inputTableIdentifierColumns23a;
811 if (isMetafacadePropertyCachingEnabled())
812 {
813 this.__inputTableIdentifierColumns23aSet = true;
814 }
815 }
816 return inputTableIdentifierColumns23a;
817 }
818
819 /**
820 * @see org.andromda.cartridges.jsf2.metafacades.JSFAttribute#getMaxLength()
821 * @return String
822 */
823 protected abstract String handleGetMaxLength();
824
825 private String __maxLength24a;
826 private boolean __maxLength24aSet = false;
827
828 /**
829 * The max length allowed in the input component
830 * @return (String)handleGetMaxLength()
831 */
832 public final String getMaxLength()
833 {
834 String maxLength24a = this.__maxLength24a;
835 if (!this.__maxLength24aSet)
836 {
837 // maxLength has no pre constraints
838 maxLength24a = handleGetMaxLength();
839 // maxLength has no post constraints
840 this.__maxLength24a = maxLength24a;
841 if (isMetafacadePropertyCachingEnabled())
842 {
843 this.__maxLength24aSet = true;
844 }
845 }
846 return maxLength24a;
847 }
848
849 // ---------------- business methods ----------------------
850
851 /**
852 * Method to be implemented in descendants
853 * Retrieves the name of the form property for this attribute by taking the name of the owner
854 * property.
855 * @param ownerParameter
856 * @return String
857 */
858 protected abstract String handleGetFormPropertyName(ParameterFacade ownerParameter);
859
860 /**
861 * Retrieves the name of the form property for this attribute by taking the name of the owner
862 * property.
863 * @param ownerParameter ParameterFacade
864 * The parent that is the owner of this parameter.
865 * @return handleGetFormPropertyName(ownerParameter)
866 */
867 public String getFormPropertyName(ParameterFacade ownerParameter)
868 {
869 // getFormPropertyName has no pre constraints
870 String returnValue = handleGetFormPropertyName(ownerParameter);
871 // getFormPropertyName has no post constraints
872 return returnValue;
873 }
874
875 /**
876 * Method to be implemented in descendants
877 * Gets the unique id of this attribute on the form.
878 * @param ownerParameter
879 * @return String
880 */
881 protected abstract String handleGetFormPropertyId(ParameterFacade ownerParameter);
882
883 /**
884 * Gets the unique id of this attribute on the form.
885 * @param ownerParameter ParameterFacade
886 * The parameter that is the owner of this attribute.
887 * @return handleGetFormPropertyId(ownerParameter)
888 */
889 public String getFormPropertyId(ParameterFacade ownerParameter)
890 {
891 // getFormPropertyId has no pre constraints
892 String returnValue = handleGetFormPropertyId(ownerParameter);
893 // getFormPropertyId has no post constraints
894 return returnValue;
895 }
896
897 /**
898 * Method to be implemented in descendants
899 * Gets backing list name for this attribute. This is useful if you want to be able to select
900 * the attribute value from a list (i.e. a drop-down select input type).
901 * @param ownerParameter
902 * @return String
903 */
904 protected abstract String handleGetBackingListName(ParameterFacade ownerParameter);
905
906 /**
907 * Gets backing list name for this attribute. This is useful if you want to be able to select
908 * the attribute value from a list (i.e. a drop-down select input type).
909 * @param ownerParameter ParameterFacade
910 * The parameter that is the owner of this attribute.
911 * @return handleGetBackingListName(ownerParameter)
912 */
913 public String getBackingListName(ParameterFacade ownerParameter)
914 {
915 // getBackingListName has no pre constraints
916 String returnValue = handleGetBackingListName(ownerParameter);
917 // getBackingListName has no post constraints
918 return returnValue;
919 }
920
921 /**
922 * Method to be implemented in descendants
923 * Gets the name of the label list for this parameter. The label list name is the name of the
924 * list storing the labels for the possible values of this attribute (typically used for the
925 * labels of a drop-down select lists).
926 * @param ownerParameter
927 * @return String
928 */
929 protected abstract String handleGetLabelListName(ParameterFacade ownerParameter);
930
931 /**
932 * Gets the name of the label list for this parameter. The label list name is the name of the
933 * list storing the labels for the possible values of this attribute (typically used for the
934 * labels of a drop-down select lists).
935 * @param ownerParameter ParameterFacade
936 * The parameter that is the owner of this attribute.
937 * @return handleGetLabelListName(ownerParameter)
938 */
939 public String getLabelListName(ParameterFacade ownerParameter)
940 {
941 // getLabelListName has no pre constraints
942 String returnValue = handleGetLabelListName(ownerParameter);
943 // getLabelListName has no post constraints
944 return returnValue;
945 }
946
947 /**
948 * Method to be implemented in descendants
949 * Gets the name of the value list for this parameter; this list stores the possible values that
950 * this attribute may be (typically used for the values of a drop-down select list).
951 * @param ownerParameter
952 * @return String
953 */
954 protected abstract String handleGetValueListName(ParameterFacade ownerParameter);
955
956 /**
957 * Gets the name of the value list for this parameter; this list stores the possible values that
958 * this attribute may be (typically used for the values of a drop-down select list).
959 * @param ownerParameter ParameterFacade
960 * The parameter that is the owner of this attribute.
961 * @return handleGetValueListName(ownerParameter)
962 */
963 public String getValueListName(ParameterFacade ownerParameter)
964 {
965 // getValueListName has no pre constraints
966 String returnValue = handleGetValueListName(ownerParameter);
967 // getValueListName has no post constraints
968 return returnValue;
969 }
970
971 /**
972 * Method to be implemented in descendants
973 * Indicates whether or not this attribute is selectable according to its 'ownerParameter'.
974 * @param ownerParameter
975 * @return boolean
976 */
977 protected abstract boolean handleIsSelectable(FrontEndParameter ownerParameter);
978
979 /**
980 * Indicates whether or not this attribute is selectable according to its 'ownerParameter'.
981 * @param ownerParameter FrontEndParameter
982 * The parameter that 'owns' this attribute.
983 * @return handleIsSelectable(ownerParameter)
984 */
985 public boolean isSelectable(FrontEndParameter ownerParameter)
986 {
987 // isSelectable has no pre constraints
988 boolean returnValue = handleIsSelectable(ownerParameter);
989 // isSelectable has no post constraints
990 return returnValue;
991 }
992
993 /**
994 * Method to be implemented in descendants
995 * Gets the arguments for this parameter's validators.
996 * @param validatorType
997 * @return Collection
998 */
999 protected abstract Collection handleGetValidatorArgs(String validatorType);
1000
1001 /**
1002 * Gets the arguments for this parameter's validators.
1003 * @param validatorType String
1004 * The type of validator.
1005 * @return handleGetValidatorArgs(validatorType)
1006 */
1007 public Collection getValidatorArgs(String validatorType)
1008 {
1009 // getValidatorArgs has no pre constraints
1010 Collection returnValue = handleGetValidatorArgs(validatorType);
1011 // getValidatorArgs has no post constraints
1012 return returnValue;
1013 }
1014
1015 /**
1016 * Method to be implemented in descendants
1017 * Gets the name of the date formatter for this attribute by constructing the name from the
1018 * 'ownerParameter' (if this attribute represents a date).
1019 * @param ownerParameter
1020 * @return String
1021 */
1022 protected abstract String handleGetDateFormatter(JSFParameter ownerParameter);
1023
1024 /**
1025 * Gets the name of the date formatter for this attribute by constructing the name from the
1026 * 'ownerParameter' (if this attribute represents a date).
1027 * @param ownerParameter JSFParameter
1028 * The parameter that is the 'owner' of this attribute.
1029 * @return handleGetDateFormatter(ownerParameter)
1030 */
1031 public String getDateFormatter(JSFParameter ownerParameter)
1032 {
1033 // getDateFormatter has no pre constraints
1034 String returnValue = handleGetDateFormatter(ownerParameter);
1035 // getDateFormatter has no post constraints
1036 return returnValue;
1037 }
1038
1039 /**
1040 * Method to be implemented in descendants
1041 * Gets the name of the time formatter (if this parameter represents a time).
1042 * @param ownerParameter
1043 * @return String
1044 */
1045 protected abstract String handleGetTimeFormatter(JSFParameter ownerParameter);
1046
1047 /**
1048 * Gets the name of the time formatter (if this parameter represents a time).
1049 * @param ownerParameter JSFParameter
1050 * The parameter that is the 'owner' of this attribute.
1051 * @return handleGetTimeFormatter(ownerParameter)
1052 */
1053 public String getTimeFormatter(JSFParameter ownerParameter)
1054 {
1055 // getTimeFormatter has no pre constraints
1056 String returnValue = handleGetTimeFormatter(ownerParameter);
1057 // getTimeFormatter has no post constraints
1058 return returnValue;
1059 }
1060
1061 /**
1062 * Method to be implemented in descendants
1063 * Constructs and returns the backing value name given the 'ownerParameter'.
1064 * @param ownerParameter
1065 * @return String
1066 */
1067 protected abstract String handleGetBackingValueName(ParameterFacade ownerParameter);
1068
1069 /**
1070 * Constructs and returns the backing value name given the 'ownerParameter'.
1071 * @param ownerParameter ParameterFacade
1072 * The parameter that is the "owner" of this attribute (i.e. the parameter's type contains this
1073 * attribute).
1074 * @return handleGetBackingValueName(ownerParameter)
1075 */
1076 public String getBackingValueName(ParameterFacade ownerParameter)
1077 {
1078 // getBackingValueName has no pre constraints
1079 String returnValue = handleGetBackingValueName(ownerParameter);
1080 // getBackingValueName has no post constraints
1081 return returnValue;
1082 }
1083
1084 /**
1085 * Method to be implemented in descendants
1086 * Indicates whether or not the backing value is required for this attribute (depending on the
1087 * 'ownerParameter').
1088 * @param ownerParameter
1089 * @return boolean
1090 */
1091 protected abstract boolean handleIsBackingValueRequired(FrontEndParameter ownerParameter);
1092
1093 /**
1094 * Indicates whether or not the backing value is required for this attribute (depending on the
1095 * 'ownerParameter').
1096 * @param ownerParameter FrontEndParameter
1097 * The 'owner' of this attribute (i.e. the attrubte who's type has this attribute).
1098 * @return handleIsBackingValueRequired(ownerParameter)
1099 */
1100 public boolean isBackingValueRequired(FrontEndParameter ownerParameter)
1101 {
1102 // isBackingValueRequired has no pre constraints
1103 boolean returnValue = handleIsBackingValueRequired(ownerParameter);
1104 // isBackingValueRequired has no post constraints
1105 return returnValue;
1106 }
1107
1108 /**
1109 * Method to be implemented in descendants
1110 * Gets the validator args for this attribute
1111 * @param ownerParameter
1112 * @return Collection
1113 */
1114 protected abstract Collection handleGetValidatorVars(JSFParameter ownerParameter);
1115
1116 /**
1117 * Gets the validator args for this attribute
1118 * @param ownerParameter JSFParameter
1119 * TODO: Model Documentation for
1120 * org.andromda.cartridges.jsf2.metafacades.JSFAttribute.getValidatorVars(ownerParameter)
1121 * @return handleGetValidatorVars(ownerParameter)
1122 */
1123 public Collection getValidatorVars(JSFParameter ownerParameter)
1124 {
1125 // getValidatorVars has no pre constraints
1126 Collection returnValue = handleGetValidatorVars(ownerParameter);
1127 // getValidatorVars has no post constraints
1128 return returnValue;
1129 }
1130
1131 /**
1132 * @return true
1133 * @see AttributeFacade
1134 */
1135 public boolean isAttributeFacadeMetaType()
1136 {
1137 return true;
1138 }
1139
1140 /**
1141 * @return true
1142 * @see ModelElementFacade
1143 */
1144 public boolean isModelElementFacadeMetaType()
1145 {
1146 return true;
1147 }
1148
1149 // ----------- delegates to AttributeFacade ------------
1150 /**
1151 * Searches the given feature for the specified tag.
1152 * If the follow boolean is set to true then the search will continue from the class attribute
1153 * to the class itself and then up the class hierarchy.
1154 * @see AttributeFacade#findTaggedValue(String name, boolean follow)
1155 */
1156 public Object findTaggedValue(String name, boolean follow)
1157 {
1158 return this.getSuperAttributeFacade().findTaggedValue(name, follow);
1159 }
1160
1161 /**
1162 * The default value of the attribute. This is the value given if no value is defined.
1163 * @see AttributeFacade#getDefaultValue()
1164 */
1165 public String getDefaultValue()
1166 {
1167 return this.getSuperAttributeFacade().getDefaultValue();
1168 }
1169
1170 /**
1171 * If the attribute is an enumeration literal this represents the owning enumeration. Can be
1172 * empty.
1173 * @see AttributeFacade#getEnumeration()
1174 */
1175 public EnumerationFacade getEnumeration()
1176 {
1177 return this.getSuperAttributeFacade().getEnumeration();
1178 }
1179
1180 /**
1181 * Returns the enumeration literal parameters defined by tagged value as a comma separated list.
1182 * @see AttributeFacade#getEnumerationLiteralParameters()
1183 */
1184 public String getEnumerationLiteralParameters()
1185 {
1186 return this.getSuperAttributeFacade().getEnumerationLiteralParameters();
1187 }
1188
1189 /**
1190 * The value for this attribute if it is an enumeration literal, null otherwise. The default
1191 * value is returned as a String if it has been specified, if it's not specified this
1192 * attribute's name is assumed.
1193 * @see AttributeFacade#getEnumerationValue()
1194 */
1195 public String getEnumerationValue()
1196 {
1197 return this.getSuperAttributeFacade().getEnumerationValue();
1198 }
1199
1200 /**
1201 * The name of the accessor operation that would retrieve this attribute's value.
1202 * @see AttributeFacade#getGetterName()
1203 */
1204 public String getGetterName()
1205 {
1206 return this.getSuperAttributeFacade().getGetterName();
1207 }
1208
1209 /**
1210 * The name of the type that is returned on the accessor and mutator operations, determined in
1211 * part by the multiplicity.
1212 * @see AttributeFacade#getGetterSetterTypeName()
1213 */
1214 public String getGetterSetterTypeName()
1215 {
1216 return this.getSuperAttributeFacade().getGetterSetterTypeName();
1217 }
1218
1219 /**
1220 * the lower value for the multiplicity
1221 * -only applicable for UML2
1222 * @see AttributeFacade#getLower()
1223 */
1224 public int getLower()
1225 {
1226 return this.getSuperAttributeFacade().getLower();
1227 }
1228
1229 /**
1230 * Gets the classifier who is the owner of the attributes.
1231 * @see AttributeFacade#getOwner()
1232 */
1233 public ClassifierFacade getOwner()
1234 {
1235 return this.getSuperAttributeFacade().getOwner();
1236 }
1237
1238 /**
1239 * The name of the mutator operation that would retrieve this attribute's value.
1240 * @see AttributeFacade#getSetterName()
1241 */
1242 public String getSetterName()
1243 {
1244 return this.getSuperAttributeFacade().getSetterName();
1245 }
1246
1247 /**
1248 * The classifier owning this attribute.
1249 * @see AttributeFacade#getType()
1250 */
1251 public ClassifierFacade getType()
1252 {
1253 return this.getSuperAttributeFacade().getType();
1254 }
1255
1256 /**
1257 * the upper value for the multiplicity (will be -1 for *)
1258 * -only applicable for UML2
1259 * @see AttributeFacade#getUpper()
1260 */
1261 public int getUpper()
1262 {
1263 return this.getSuperAttributeFacade().getUpper();
1264 }
1265
1266 /**
1267 * True if this attribute can only be set.
1268 * @see AttributeFacade#isAddOnly()
1269 */
1270 public boolean isAddOnly()
1271 {
1272 return this.getSuperAttributeFacade().isAddOnly();
1273 }
1274
1275 /**
1276 * True if this attribute can be modified.
1277 * @see AttributeFacade#isChangeable()
1278 */
1279 public boolean isChangeable()
1280 {
1281 return this.getSuperAttributeFacade().isChangeable();
1282 }
1283
1284 /**
1285 * Indicates if the default value is present.
1286 * @see AttributeFacade#isDefaultValuePresent()
1287 */
1288 public boolean isDefaultValuePresent()
1289 {
1290 return this.getSuperAttributeFacade().isDefaultValuePresent();
1291 }
1292
1293 /**
1294 * If the attribute is derived (its value is computed). UML2 only. UML14 always returns false.
1295 * Default=false.
1296 * @see AttributeFacade#isDerived()
1297 */
1298 public boolean isDerived()
1299 {
1300 return this.getSuperAttributeFacade().isDerived();
1301 }
1302
1303 /**
1304 * True if this attribute is owned by an enumeration.
1305 * @see AttributeFacade#isEnumerationLiteral()
1306 */
1307 public boolean isEnumerationLiteral()
1308 {
1309 return this.getSuperAttributeFacade().isEnumerationLiteral();
1310 }
1311
1312 /**
1313 * Returns true if enumeration literal parameters exist (defined by tagged value) for the
1314 * literal.
1315 * @see AttributeFacade#isEnumerationLiteralParametersExist()
1316 */
1317 public boolean isEnumerationLiteralParametersExist()
1318 {
1319 return this.getSuperAttributeFacade().isEnumerationLiteralParametersExist();
1320 }
1321
1322 /**
1323 * True if this attribute is owned by an enumeration but is defined as a member variable (NOT a
1324 * literal).
1325 * @see AttributeFacade#isEnumerationMember()
1326 */
1327 public boolean isEnumerationMember()
1328 {
1329 return this.getSuperAttributeFacade().isEnumerationMember();
1330 }
1331
1332 /**
1333 * IsLeaf property in the operation. If true, operation is final, cannot be extended or
1334 * implemented by a descendant.
1335 * @see AttributeFacade#isLeaf()
1336 */
1337 public boolean isLeaf()
1338 {
1339 return this.getSuperAttributeFacade().isLeaf();
1340 }
1341
1342 /**
1343 * Whether or not this attribute has a multiplicity greater than 1.
1344 * @see AttributeFacade#isMany()
1345 */
1346 public boolean isMany()
1347 {
1348 return this.getSuperAttributeFacade().isMany();
1349 }
1350
1351 /**
1352 * Indicates whether or not the attributes are ordered (if multiplicity is greater than 1).
1353 * @see AttributeFacade#isOrdered()
1354 */
1355 public boolean isOrdered()
1356 {
1357 return this.getSuperAttributeFacade().isOrdered();
1358 }
1359
1360 /**
1361 * Whether or not this attribute can be modified.
1362 * @see AttributeFacade#isReadOnly()
1363 */
1364 public boolean isReadOnly()
1365 {
1366 return this.getSuperAttributeFacade().isReadOnly();
1367 }
1368
1369 /**
1370 * Whether or not the multiplicity of this attribute is 1.
1371 * @see AttributeFacade#isRequired()
1372 */
1373 public boolean isRequired()
1374 {
1375 return this.getSuperAttributeFacade().isRequired();
1376 }
1377
1378 /**
1379 * Indicates if this attribute is 'static', meaning it has a classifier scope.
1380 * @see AttributeFacade#isStatic()
1381 */
1382 public boolean isStatic()
1383 {
1384 return this.getSuperAttributeFacade().isStatic();
1385 }
1386
1387 /**
1388 * If the attribute is unique within the Collection type. UML2 only. UML14 always returns false.
1389 * Unique+Ordered determines the implementation Collection type. Default=false.
1390 * @see AttributeFacade#isUnique()
1391 */
1392 public boolean isUnique()
1393 {
1394 return this.getSuperAttributeFacade().isUnique();
1395 }
1396
1397 /**
1398 * Copies all tagged values from the given ModelElementFacade to this model element facade.
1399 * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element)
1400 */
1401 public void copyTaggedValues(ModelElementFacade element)
1402 {
1403 this.getSuperAttributeFacade().copyTaggedValues(element);
1404 }
1405
1406 /**
1407 * Finds the tagged value with the specified 'tagName'. In case there are more values the first
1408 * one found will be returned.
1409 * @see ModelElementFacade#findTaggedValue(String tagName)
1410 */
1411 public Object findTaggedValue(String tagName)
1412 {
1413 return this.getSuperAttributeFacade().findTaggedValue(tagName);
1414 }
1415
1416 /**
1417 * Returns all the values for the tagged value with the specified name. The returned collection
1418 * will contains only String instances, or will be empty. Never null.
1419 * @see ModelElementFacade#findTaggedValues(String tagName)
1420 */
1421 public Collection<Object> findTaggedValues(String tagName)
1422 {
1423 return this.getSuperAttributeFacade().findTaggedValues(tagName);
1424 }
1425
1426 /**
1427 * Returns the fully qualified name of the model element. The fully qualified name includes
1428 * complete package qualified name of the underlying model element. The templates parameter will
1429 * be replaced by the correct one given the binding relation of the parameter to this element.
1430 * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement)
1431 */
1432 public String getBindedFullyQualifiedName(ModelElementFacade bindedElement)
1433 {
1434 return this.getSuperAttributeFacade().getBindedFullyQualifiedName(bindedElement);
1435 }
1436
1437 /**
1438 * Gets all constraints belonging to the model element.
1439 * @see ModelElementFacade#getConstraints()
1440 */
1441 public Collection<ConstraintFacade> getConstraints()
1442 {
1443 return this.getSuperAttributeFacade().getConstraints();
1444 }
1445
1446 /**
1447 * Returns the constraints of the argument kind that have been placed onto this model. Typical
1448 * kinds are "inv", "pre" and "post". Other kinds are possible.
1449 * @see ModelElementFacade#getConstraints(String kind)
1450 */
1451 public Collection<ConstraintFacade> getConstraints(String kind)
1452 {
1453 return this.getSuperAttributeFacade().getConstraints(kind);
1454 }
1455
1456 /**
1457 * Gets the documentation for the model element, The indent argument is prefixed to each line.
1458 * By default this method wraps lines after 64 characters.
1459 * This method is equivalent to <code>getDocumentation(indent, 64)</code>.
1460 * @see ModelElementFacade#getDocumentation(String indent)
1461 */
1462 public String getDocumentation(String indent)
1463 {
1464 return this.getSuperAttributeFacade().getDocumentation(indent);
1465 }
1466
1467 /**
1468 * This method returns the documentation for this model element, with the lines wrapped after
1469 * the specified number of characters, values of less than 1 will indicate no line wrapping is
1470 * required. By default paragraphs are returned as HTML.
1471 * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>.
1472 * @see ModelElementFacade#getDocumentation(String indent, int lineLength)
1473 */
1474 public String getDocumentation(String indent, int lineLength)
1475 {
1476 return this.getSuperAttributeFacade().getDocumentation(indent, lineLength);
1477 }
1478
1479 /**
1480 * This method returns the documentation for this model element, with the lines wrapped after
1481 * the specified number of characters, values of less than 1 will indicate no line wrapping is
1482 * required. HTML style determines if HTML Escaping is applied.
1483 * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle)
1484 */
1485 public String getDocumentation(String indent, int lineLength, boolean htmlStyle)
1486 {
1487 return this.getSuperAttributeFacade().getDocumentation(indent, lineLength, htmlStyle);
1488 }
1489
1490 /**
1491 * The fully qualified name of this model element.
1492 * @see ModelElementFacade#getFullyQualifiedName()
1493 */
1494 public String getFullyQualifiedName()
1495 {
1496 return this.getSuperAttributeFacade().getFullyQualifiedName();
1497 }
1498
1499 /**
1500 * Returns the fully qualified name of the model element. The fully qualified name includes
1501 * complete package qualified name of the underlying model element. If modelName is true, then
1502 * the original name of the model element (the name contained within the model) will be the name
1503 * returned, otherwise a name from a language mapping will be returned.
1504 * @see ModelElementFacade#getFullyQualifiedName(boolean modelName)
1505 */
1506 public String getFullyQualifiedName(boolean modelName)
1507 {
1508 return this.getSuperAttributeFacade().getFullyQualifiedName(modelName);
1509 }
1510
1511 /**
1512 * Returns the fully qualified name as a path, the returned value always starts with out a slash
1513 * '/'.
1514 * @see ModelElementFacade#getFullyQualifiedNamePath()
1515 */
1516 public String getFullyQualifiedNamePath()
1517 {
1518 return this.getSuperAttributeFacade().getFullyQualifiedNamePath();
1519 }
1520
1521 /**
1522 * Gets the unique identifier of the underlying model element.
1523 * @see ModelElementFacade#getId()
1524 */
1525 public String getId()
1526 {
1527 return this.getSuperAttributeFacade().getId();
1528 }
1529
1530 /**
1531 * UML2: Retrieves the keywords for this element. Used to modify implementation properties which
1532 * are not represented by other properties, i.e. native, transient, volatile, synchronized,
1533 * (added annotations) override, deprecated. Can also be used to suppress compiler warnings:
1534 * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require
1535 * JDK5 compiler level.
1536 * @see ModelElementFacade#getKeywords()
1537 */
1538 public Collection<String> getKeywords()
1539 {
1540 return this.getSuperAttributeFacade().getKeywords();
1541 }
1542
1543 /**
1544 * UML2: Retrieves a localized label for this named element.
1545 * @see ModelElementFacade#getLabel()
1546 */
1547 public String getLabel()
1548 {
1549 return this.getSuperAttributeFacade().getLabel();
1550 }
1551
1552 /**
1553 * The language mappings that have been set for this model element.
1554 * @see ModelElementFacade#getLanguageMappings()
1555 */
1556 public TypeMappings getLanguageMappings()
1557 {
1558 return this.getSuperAttributeFacade().getLanguageMappings();
1559 }
1560
1561 /**
1562 * Return the model containing this model element (multiple models may be loaded and processed
1563 * at the same time).
1564 * @see ModelElementFacade#getModel()
1565 */
1566 public ModelFacade getModel()
1567 {
1568 return this.getSuperAttributeFacade().getModel();
1569 }
1570
1571 /**
1572 * The name of the model element.
1573 * @see ModelElementFacade#getName()
1574 */
1575 public String getName()
1576 {
1577 return this.getSuperAttributeFacade().getName();
1578 }
1579
1580 /**
1581 * Gets the package to which this model element belongs.
1582 * @see ModelElementFacade#getPackage()
1583 */
1584 public ModelElementFacade getPackage()
1585 {
1586 return this.getSuperAttributeFacade().getPackage();
1587 }
1588
1589 /**
1590 * The name of this model element's package.
1591 * @see ModelElementFacade#getPackageName()
1592 */
1593 public String getPackageName()
1594 {
1595 return this.getSuperAttributeFacade().getPackageName();
1596 }
1597
1598 /**
1599 * Gets the package name (optionally providing the ability to retrieve the model name and not
1600 * the mapped name).
1601 * @see ModelElementFacade#getPackageName(boolean modelName)
1602 */
1603 public String getPackageName(boolean modelName)
1604 {
1605 return this.getSuperAttributeFacade().getPackageName(modelName);
1606 }
1607
1608 /**
1609 * Returns the package as a path, the returned value always starts with out a slash '/'.
1610 * @see ModelElementFacade#getPackagePath()
1611 */
1612 public String getPackagePath()
1613 {
1614 return this.getSuperAttributeFacade().getPackagePath();
1615 }
1616
1617 /**
1618 * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the
1619 * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from
1620 * the names of the containing namespaces starting at the root of the hierarchy and ending with
1621 * the name of the NamedElement itself.
1622 * @see ModelElementFacade#getQualifiedName()
1623 */
1624 public String getQualifiedName()
1625 {
1626 return this.getSuperAttributeFacade().getQualifiedName();
1627 }
1628
1629 /**
1630 * Gets the root package for the model element.
1631 * @see ModelElementFacade#getRootPackage()
1632 */
1633 public PackageFacade getRootPackage()
1634 {
1635 return this.getSuperAttributeFacade().getRootPackage();
1636 }
1637
1638 /**
1639 * Gets the dependencies for which this model element is the source.
1640 * @see ModelElementFacade#getSourceDependencies()
1641 */
1642 public Collection<DependencyFacade> getSourceDependencies()
1643 {
1644 return this.getSuperAttributeFacade().getSourceDependencies();
1645 }
1646
1647 /**
1648 * If this model element is the context of an activity graph, this represents that activity
1649 * graph.
1650 * @see ModelElementFacade#getStateMachineContext()
1651 */
1652 public StateMachineFacade getStateMachineContext()
1653 {
1654 return this.getSuperAttributeFacade().getStateMachineContext();
1655 }
1656
1657 /**
1658 * The collection of ALL stereotype names for this model element.
1659 * @see ModelElementFacade#getStereotypeNames()
1660 */
1661 public Collection<String> getStereotypeNames()
1662 {
1663 return this.getSuperAttributeFacade().getStereotypeNames();
1664 }
1665
1666 /**
1667 * Gets all stereotypes for this model element.
1668 * @see ModelElementFacade#getStereotypes()
1669 */
1670 public Collection<StereotypeFacade> getStereotypes()
1671 {
1672 return this.getSuperAttributeFacade().getStereotypes();
1673 }
1674
1675 /**
1676 * Return the TaggedValues associated with this model element, under all stereotypes.
1677 * @see ModelElementFacade#getTaggedValues()
1678 */
1679 public Collection<TaggedValueFacade> getTaggedValues()
1680 {
1681 return this.getSuperAttributeFacade().getTaggedValues();
1682 }
1683
1684 /**
1685 * Gets the dependencies for which this model element is the target.
1686 * @see ModelElementFacade#getTargetDependencies()
1687 */
1688 public Collection<DependencyFacade> getTargetDependencies()
1689 {
1690 return this.getSuperAttributeFacade().getTargetDependencies();
1691 }
1692
1693 /**
1694 * Get the template parameter for this model element having the parameterName
1695 * @see ModelElementFacade#getTemplateParameter(String parameterName)
1696 */
1697 public Object getTemplateParameter(String parameterName)
1698 {
1699 return this.getSuperAttributeFacade().getTemplateParameter(parameterName);
1700 }
1701
1702 /**
1703 * Get the template parameters for this model element
1704 * @see ModelElementFacade#getTemplateParameters()
1705 */
1706 public Collection<TemplateParameterFacade> getTemplateParameters()
1707 {
1708 return this.getSuperAttributeFacade().getTemplateParameters();
1709 }
1710
1711 /**
1712 * The visibility (i.e. public, private, protected or package) of the model element, will
1713 * attempt a lookup for these values in the language mappings (if any).
1714 * @see ModelElementFacade#getVisibility()
1715 */
1716 public String getVisibility()
1717 {
1718 return this.getSuperAttributeFacade().getVisibility();
1719 }
1720
1721 /**
1722 * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance
1723 * is taken into account when searching for the stereotype), false otherwise.
1724 * @see ModelElementFacade#hasExactStereotype(String stereotypeName)
1725 */
1726 public boolean hasExactStereotype(String stereotypeName)
1727 {
1728 return this.getSuperAttributeFacade().hasExactStereotype(stereotypeName);
1729 }
1730
1731 /**
1732 * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma,
1733 * pipe, semicolon, or << >>
1734 * @see ModelElementFacade#hasKeyword(String keywordName)
1735 */
1736 public boolean hasKeyword(String keywordName)
1737 {
1738 return this.getSuperAttributeFacade().hasKeyword(keywordName);
1739 }
1740
1741 /**
1742 * Returns true if the model element has the specified stereotype. If the stereotype itself
1743 * does not match, then a search will be made up the stereotype inheritance hierarchy, and if
1744 * one of the stereotype's ancestors has a matching name this method will return true, false
1745 * otherwise.
1746 * For example, if we have a certain stereotype called <<exception>> and a model element has a
1747 * stereotype called <<applicationException>> which extends <<exception>>, when calling this
1748 * method with 'stereotypeName' defined as 'exception' the method would return true since
1749 * <<applicationException>> inherits from <<exception>>. If you want to check if the model
1750 * element has the exact stereotype, then use the method 'hasExactStereotype' instead.
1751 * @see ModelElementFacade#hasStereotype(String stereotypeName)
1752 */
1753 public boolean hasStereotype(String stereotypeName)
1754 {
1755 return this.getSuperAttributeFacade().hasStereotype(stereotypeName);
1756 }
1757
1758 /**
1759 * True if there are target dependencies from this element that are instances of BindingFacade.
1760 * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies.
1761 * @see ModelElementFacade#isBindingDependenciesPresent()
1762 */
1763 public boolean isBindingDependenciesPresent()
1764 {
1765 return this.getSuperAttributeFacade().isBindingDependenciesPresent();
1766 }
1767
1768 /**
1769 * Indicates if any constraints are present on this model element.
1770 * @see ModelElementFacade#isConstraintsPresent()
1771 */
1772 public boolean isConstraintsPresent()
1773 {
1774 return this.getSuperAttributeFacade().isConstraintsPresent();
1775 }
1776
1777 /**
1778 * Indicates if any documentation is present on this model element.
1779 * @see ModelElementFacade#isDocumentationPresent()
1780 */
1781 public boolean isDocumentationPresent()
1782 {
1783 return this.getSuperAttributeFacade().isDocumentationPresent();
1784 }
1785
1786 /**
1787 * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript.
1788 * @see ModelElementFacade#isReservedWord()
1789 */
1790 public boolean isReservedWord()
1791 {
1792 return this.getSuperAttributeFacade().isReservedWord();
1793 }
1794
1795 /**
1796 * True is there are template parameters on this model element. For UML2, applies to Class,
1797 * Operation, Property, and Parameter.
1798 * @see ModelElementFacade#isTemplateParametersPresent()
1799 */
1800 public boolean isTemplateParametersPresent()
1801 {
1802 return this.getSuperAttributeFacade().isTemplateParametersPresent();
1803 }
1804
1805 /**
1806 * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++,
1807 * JavaScript. Contains no spaces, special characters etc. Constraint always applied on
1808 * Enumerations and Interfaces, optionally applies on other model elements.
1809 * @see ModelElementFacade#isValidIdentifierName()
1810 */
1811 public boolean isValidIdentifierName()
1812 {
1813 return this.getSuperAttributeFacade().isValidIdentifierName();
1814 }
1815
1816 /**
1817 * Searches for the constraint with the specified 'name' on this model element, and if found
1818 * translates it using the specified 'translation' from a translation library discovered by the
1819 * framework.
1820 * @see ModelElementFacade#translateConstraint(String name, String translation)
1821 */
1822 public String translateConstraint(String name, String translation)
1823 {
1824 return this.getSuperAttributeFacade().translateConstraint(name, translation);
1825 }
1826
1827 /**
1828 * Translates all constraints belonging to this model element with the given 'translation'.
1829 * @see ModelElementFacade#translateConstraints(String translation)
1830 */
1831 public String[] translateConstraints(String translation)
1832 {
1833 return this.getSuperAttributeFacade().translateConstraints(translation);
1834 }
1835
1836 /**
1837 * Translates the constraints of the specified 'kind' belonging to this model element.
1838 * @see ModelElementFacade#translateConstraints(String kind, String translation)
1839 */
1840 public String[] translateConstraints(String kind, String translation)
1841 {
1842 return this.getSuperAttributeFacade().translateConstraints(kind, translation);
1843 }
1844
1845 /**
1846 * @see org.andromda.core.metafacade.MetafacadeBase#initialize()
1847 */
1848 @Override
1849 public void initialize()
1850 {
1851 this.getSuperAttributeFacade().initialize();
1852 }
1853
1854 /**
1855 * @return Object getSuperAttributeFacade().getValidationOwner()
1856 * @see org.andromda.core.metafacade.MetafacadeBase#getValidationOwner()
1857 */
1858 @Override
1859 public Object getValidationOwner()
1860 {
1861 Object owner = this.getSuperAttributeFacade().getValidationOwner();
1862 return owner;
1863 }
1864
1865 /**
1866 * @return String getSuperAttributeFacade().getValidationName()
1867 * @see org.andromda.core.metafacade.MetafacadeBase#getValidationName()
1868 */
1869 @Override
1870 public String getValidationName()
1871 {
1872 String name = this.getSuperAttributeFacade().getValidationName();
1873 return name;
1874 }
1875
1876 /**
1877 * @param validationMessages Collection<ModelValidationMessage>
1878 * @see org.andromda.core.metafacade.MetafacadeBase#validateInvariants(Collection validationMessages)
1879 */
1880 @Override
1881 public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
1882 {
1883 this.getSuperAttributeFacade().validateInvariants(validationMessages);
1884 }
1885
1886 /**
1887 * The property that stores the name of the metafacade.
1888 */
1889 private static final String NAME_PROPERTY = "name";
1890 private static final String FQNAME_PROPERTY = "fullyQualifiedName";
1891
1892 /**
1893 * @see Object#toString()
1894 */
1895 @Override
1896 public String toString()
1897 {
1898 final StringBuilder toString = new StringBuilder(this.getClass().getName());
1899 toString.append("[");
1900 try
1901 {
1902 toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY));
1903 }
1904 catch (final Throwable tryAgain)
1905 {
1906 try
1907 {
1908 toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY));
1909 }
1910 catch (final Throwable ignore)
1911 {
1912 // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property
1913 }
1914 }
1915 toString.append("]");
1916 return toString.toString();
1917 }
1918 }