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