1 // license-header java merge-point
2 //
3 // Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
4 //
5 package org.andromda.cartridges.spring.metafacades;
6
7 import java.util.Collection;
8 import java.util.List;
9 import org.andromda.core.common.Introspector;
10 import org.andromda.core.metafacade.MetafacadeBase;
11 import org.andromda.core.metafacade.MetafacadeFactory;
12 import org.andromda.core.metafacade.ModelValidationMessage;
13 import org.andromda.metafacades.uml.ActorFacade;
14 import org.andromda.metafacades.uml.AssociationEndFacade;
15 import org.andromda.metafacades.uml.AttributeFacade;
16 import org.andromda.metafacades.uml.ClassifierFacade;
17 import org.andromda.metafacades.uml.ConstraintFacade;
18 import org.andromda.metafacades.uml.DependencyFacade;
19 import org.andromda.metafacades.uml.EntityAssociationEnd;
20 import org.andromda.metafacades.uml.EntityQueryOperation;
21 import org.andromda.metafacades.uml.GeneralizableElementFacade;
22 import org.andromda.metafacades.uml.GeneralizationFacade;
23 import org.andromda.metafacades.uml.ManageableEntity;
24 import org.andromda.metafacades.uml.ManageableEntityAssociationEnd;
25 import org.andromda.metafacades.uml.ManageableEntityAttribute;
26 import org.andromda.metafacades.uml.ModelElementFacade;
27 import org.andromda.metafacades.uml.ModelFacade;
28 import org.andromda.metafacades.uml.OperationFacade;
29 import org.andromda.metafacades.uml.PackageFacade;
30 import org.andromda.metafacades.uml.StateMachineFacade;
31 import org.andromda.metafacades.uml.StereotypeFacade;
32 import org.andromda.metafacades.uml.TaggedValueFacade;
33 import org.andromda.metafacades.uml.TemplateParameterFacade;
34 import org.andromda.metafacades.uml.TypeMappings;
35
36 /**
37 * TODO: Model Documentation for org.andromda.cartridges.spring.metafacades.SpringManageableEntity
38 * MetafacadeLogic for SpringManageableEntity
39 *
40 * @see SpringManageableEntity
41 */
42 public abstract class SpringManageableEntityLogic
43 extends MetafacadeBase
44 implements SpringManageableEntity
45 {
46 /**
47 * The underlying UML object
48 * @see Object
49 */
50 protected Object metaObject;
51
52 /** Create Metafacade implementation instance using the MetafacadeFactory from the context
53 * @param metaObjectIn
54 * @param context
55 */
56 protected SpringManageableEntityLogic(Object metaObjectIn, String context)
57 {
58 super(metaObjectIn, getContext(context));
59 this.superSpringEntity =
60 (SpringEntity)
61 MetafacadeFactory.getInstance().createFacadeImpl(
62 "org.andromda.cartridges.spring.metafacades.SpringEntity",
63 metaObjectIn,
64 getContext(context));
65 this.superManageableEntity =
66 (ManageableEntity)
67 MetafacadeFactory.getInstance().createFacadeImpl(
68 "org.andromda.metafacades.uml.ManageableEntity",
69 metaObjectIn,
70 getContext(context));
71 this.metaObject = metaObjectIn;
72 }
73
74 /**
75 * Gets the context for this metafacade logic instance.
76 * @param context String. Set to SpringManageableEntity if null
77 * @return context String
78 */
79 private static String getContext(String context)
80 {
81 if (context == null)
82 {
83 context = "org.andromda.cartridges.spring.metafacades.SpringManageableEntity";
84 }
85 return context;
86 }
87
88 private SpringEntity superSpringEntity;
89 private boolean superSpringEntityInitialized = false;
90
91 /**
92 * Gets the SpringEntity parent instance.
93 * @return this.superSpringEntity SpringEntity
94 */
95 protected SpringEntity getSuperSpringEntity()
96 {
97 if (!this.superSpringEntityInitialized)
98 {
99 ((MetafacadeBase)this.superSpringEntity).setMetafacadeContext(this.getMetafacadeContext());
100 this.superSpringEntityInitialized = true;
101 }
102 return this.superSpringEntity;
103 }
104
105 private ManageableEntity superManageableEntity;
106 private boolean superManageableEntityInitialized = false;
107
108 /**
109 * Gets the ManageableEntity parent instance.
110 * @return this.superManageableEntity ManageableEntity
111 */
112 protected ManageableEntity getSuperManageableEntity()
113 {
114 if (!this.superManageableEntityInitialized)
115 {
116 ((MetafacadeBase)this.superManageableEntity).setMetafacadeContext(this.getMetafacadeContext());
117 this.superManageableEntityInitialized = true;
118 }
119 return this.superManageableEntity;
120 }
121
122 /** Reset context only for non-root metafacades
123 * @param context
124 * @see org.andromda.core.metafacade.MetafacadeBase#resetMetafacadeContext(String context)
125 */
126 @Override
127 public void resetMetafacadeContext(String context)
128 {
129 if (!this.contextRoot) // reset context only for non-root metafacades
130 {
131 context = getContext(context); // to have same value as in original constructor call
132 setMetafacadeContext (context);
133 if (this.superSpringEntityInitialized)
134 {
135 ((MetafacadeBase)this.superSpringEntity).resetMetafacadeContext(context);
136 }
137 if (this.superManageableEntityInitialized)
138 {
139 ((MetafacadeBase)this.superManageableEntity).resetMetafacadeContext(context);
140 }
141 }
142 }
143
144 /**
145 * @return boolean true always
146 * @see SpringManageableEntity
147 */
148 public boolean isSpringManageableEntityMetaType()
149 {
150 return true;
151 }
152
153 // --------------- attributes ---------------------
154
155 /**
156 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getFullyQualifiedManageableDaoName()
157 * @return String
158 */
159 protected abstract String handleGetFullyQualifiedManageableDaoName();
160
161 private String __fullyQualifiedManageableDaoName1a;
162 private boolean __fullyQualifiedManageableDaoName1aSet = false;
163
164 /**
165 * TODO: Model Documentation for
166 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.fullyQualifiedManageableDaoName
167 * @return (String)handleGetFullyQualifiedManageableDaoName()
168 */
169 public final String getFullyQualifiedManageableDaoName()
170 {
171 String fullyQualifiedManageableDaoName1a = this.__fullyQualifiedManageableDaoName1a;
172 if (!this.__fullyQualifiedManageableDaoName1aSet)
173 {
174 // fullyQualifiedManageableDaoName has no pre constraints
175 fullyQualifiedManageableDaoName1a = handleGetFullyQualifiedManageableDaoName();
176 // fullyQualifiedManageableDaoName has no post constraints
177 this.__fullyQualifiedManageableDaoName1a = fullyQualifiedManageableDaoName1a;
178 if (isMetafacadePropertyCachingEnabled())
179 {
180 this.__fullyQualifiedManageableDaoName1aSet = true;
181 }
182 }
183 return fullyQualifiedManageableDaoName1a;
184 }
185
186 /**
187 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getManageableDaoName()
188 * @return String
189 */
190 protected abstract String handleGetManageableDaoName();
191
192 private String __manageableDaoName2a;
193 private boolean __manageableDaoName2aSet = false;
194
195 /**
196 * TODO: Model Documentation for
197 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.manageableDaoName
198 * @return (String)handleGetManageableDaoName()
199 */
200 public final String getManageableDaoName()
201 {
202 String manageableDaoName2a = this.__manageableDaoName2a;
203 if (!this.__manageableDaoName2aSet)
204 {
205 // manageableDaoName has no pre constraints
206 manageableDaoName2a = handleGetManageableDaoName();
207 // manageableDaoName has no post constraints
208 this.__manageableDaoName2a = manageableDaoName2a;
209 if (isMetafacadePropertyCachingEnabled())
210 {
211 this.__manageableDaoName2aSet = true;
212 }
213 }
214 return manageableDaoName2a;
215 }
216
217 /**
218 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getManageableDaoFullPath()
219 * @return String
220 */
221 protected abstract String handleGetManageableDaoFullPath();
222
223 private String __manageableDaoFullPath3a;
224 private boolean __manageableDaoFullPath3aSet = false;
225
226 /**
227 * TODO: Model Documentation for
228 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.manageableDaoFullPath
229 * @return (String)handleGetManageableDaoFullPath()
230 */
231 public final String getManageableDaoFullPath()
232 {
233 String manageableDaoFullPath3a = this.__manageableDaoFullPath3a;
234 if (!this.__manageableDaoFullPath3aSet)
235 {
236 // manageableDaoFullPath has no pre constraints
237 manageableDaoFullPath3a = handleGetManageableDaoFullPath();
238 // manageableDaoFullPath has no post constraints
239 this.__manageableDaoFullPath3a = manageableDaoFullPath3a;
240 if (isMetafacadePropertyCachingEnabled())
241 {
242 this.__manageableDaoFullPath3aSet = true;
243 }
244 }
245 return manageableDaoFullPath3a;
246 }
247
248 /**
249 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getManageableDaoBaseName()
250 * @return String
251 */
252 protected abstract String handleGetManageableDaoBaseName();
253
254 private String __manageableDaoBaseName4a;
255 private boolean __manageableDaoBaseName4aSet = false;
256
257 /**
258 * TODO: Model Documentation for
259 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.manageableDaoBaseName
260 * @return (String)handleGetManageableDaoBaseName()
261 */
262 public final String getManageableDaoBaseName()
263 {
264 String manageableDaoBaseName4a = this.__manageableDaoBaseName4a;
265 if (!this.__manageableDaoBaseName4aSet)
266 {
267 // manageableDaoBaseName has no pre constraints
268 manageableDaoBaseName4a = handleGetManageableDaoBaseName();
269 // manageableDaoBaseName has no post constraints
270 this.__manageableDaoBaseName4a = manageableDaoBaseName4a;
271 if (isMetafacadePropertyCachingEnabled())
272 {
273 this.__manageableDaoBaseName4aSet = true;
274 }
275 }
276 return manageableDaoBaseName4a;
277 }
278
279 /**
280 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getManageableDaoBaseFullPath()
281 * @return String
282 */
283 protected abstract String handleGetManageableDaoBaseFullPath();
284
285 private String __manageableDaoBaseFullPath5a;
286 private boolean __manageableDaoBaseFullPath5aSet = false;
287
288 /**
289 * TODO: Model Documentation for
290 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.manageableDaoBaseFullPath
291 * @return (String)handleGetManageableDaoBaseFullPath()
292 */
293 public final String getManageableDaoBaseFullPath()
294 {
295 String manageableDaoBaseFullPath5a = this.__manageableDaoBaseFullPath5a;
296 if (!this.__manageableDaoBaseFullPath5aSet)
297 {
298 // manageableDaoBaseFullPath has no pre constraints
299 manageableDaoBaseFullPath5a = handleGetManageableDaoBaseFullPath();
300 // manageableDaoBaseFullPath has no post constraints
301 this.__manageableDaoBaseFullPath5a = manageableDaoBaseFullPath5a;
302 if (isMetafacadePropertyCachingEnabled())
303 {
304 this.__manageableDaoBaseFullPath5aSet = true;
305 }
306 }
307 return manageableDaoBaseFullPath5a;
308 }
309
310 /**
311 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getFullyQualifiedManageableDaoBaseName()
312 * @return String
313 */
314 protected abstract String handleGetFullyQualifiedManageableDaoBaseName();
315
316 private String __fullyQualifiedManageableDaoBaseName6a;
317 private boolean __fullyQualifiedManageableDaoBaseName6aSet = false;
318
319 /**
320 * TODO: Model Documentation for
321 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.fullyQualifiedManageableDaoBaseName
322 * @return (String)handleGetFullyQualifiedManageableDaoBaseName()
323 */
324 public final String getFullyQualifiedManageableDaoBaseName()
325 {
326 String fullyQualifiedManageableDaoBaseName6a = this.__fullyQualifiedManageableDaoBaseName6a;
327 if (!this.__fullyQualifiedManageableDaoBaseName6aSet)
328 {
329 // fullyQualifiedManageableDaoBaseName has no pre constraints
330 fullyQualifiedManageableDaoBaseName6a = handleGetFullyQualifiedManageableDaoBaseName();
331 // fullyQualifiedManageableDaoBaseName has no post constraints
332 this.__fullyQualifiedManageableDaoBaseName6a = fullyQualifiedManageableDaoBaseName6a;
333 if (isMetafacadePropertyCachingEnabled())
334 {
335 this.__fullyQualifiedManageableDaoBaseName6aSet = true;
336 }
337 }
338 return fullyQualifiedManageableDaoBaseName6a;
339 }
340
341 /**
342 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getManageableServiceBaseFullPath()
343 * @return String
344 */
345 protected abstract String handleGetManageableServiceBaseFullPath();
346
347 private String __manageableServiceBaseFullPath7a;
348 private boolean __manageableServiceBaseFullPath7aSet = false;
349
350 /**
351 * TODO: Model Documentation for
352 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.manageableServiceBaseFullPath
353 * @return (String)handleGetManageableServiceBaseFullPath()
354 */
355 public final String getManageableServiceBaseFullPath()
356 {
357 String manageableServiceBaseFullPath7a = this.__manageableServiceBaseFullPath7a;
358 if (!this.__manageableServiceBaseFullPath7aSet)
359 {
360 // manageableServiceBaseFullPath has no pre constraints
361 manageableServiceBaseFullPath7a = handleGetManageableServiceBaseFullPath();
362 // manageableServiceBaseFullPath has no post constraints
363 this.__manageableServiceBaseFullPath7a = manageableServiceBaseFullPath7a;
364 if (isMetafacadePropertyCachingEnabled())
365 {
366 this.__manageableServiceBaseFullPath7aSet = true;
367 }
368 }
369 return manageableServiceBaseFullPath7a;
370 }
371
372 /**
373 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getManageableServiceBaseName()
374 * @return String
375 */
376 protected abstract String handleGetManageableServiceBaseName();
377
378 private String __manageableServiceBaseName8a;
379 private boolean __manageableServiceBaseName8aSet = false;
380
381 /**
382 * TODO: Model Documentation for
383 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.manageableServiceBaseName
384 * @return (String)handleGetManageableServiceBaseName()
385 */
386 public final String getManageableServiceBaseName()
387 {
388 String manageableServiceBaseName8a = this.__manageableServiceBaseName8a;
389 if (!this.__manageableServiceBaseName8aSet)
390 {
391 // manageableServiceBaseName has no pre constraints
392 manageableServiceBaseName8a = handleGetManageableServiceBaseName();
393 // manageableServiceBaseName has no post constraints
394 this.__manageableServiceBaseName8a = manageableServiceBaseName8a;
395 if (isMetafacadePropertyCachingEnabled())
396 {
397 this.__manageableServiceBaseName8aSet = true;
398 }
399 }
400 return manageableServiceBaseName8a;
401 }
402
403 /**
404 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getFullyQualifiedManageableServiceBaseName()
405 * @return String
406 */
407 protected abstract String handleGetFullyQualifiedManageableServiceBaseName();
408
409 private String __fullyQualifiedManageableServiceBaseName9a;
410 private boolean __fullyQualifiedManageableServiceBaseName9aSet = false;
411
412 /**
413 * TODO: Model Documentation for
414 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.fullyQualifiedManageableServiceBaseName
415 * @return (String)handleGetFullyQualifiedManageableServiceBaseName()
416 */
417 public final String getFullyQualifiedManageableServiceBaseName()
418 {
419 String fullyQualifiedManageableServiceBaseName9a = this.__fullyQualifiedManageableServiceBaseName9a;
420 if (!this.__fullyQualifiedManageableServiceBaseName9aSet)
421 {
422 // fullyQualifiedManageableServiceBaseName has no pre constraints
423 fullyQualifiedManageableServiceBaseName9a = handleGetFullyQualifiedManageableServiceBaseName();
424 // fullyQualifiedManageableServiceBaseName has no post constraints
425 this.__fullyQualifiedManageableServiceBaseName9a = fullyQualifiedManageableServiceBaseName9a;
426 if (isMetafacadePropertyCachingEnabled())
427 {
428 this.__fullyQualifiedManageableServiceBaseName9aSet = true;
429 }
430 }
431 return fullyQualifiedManageableServiceBaseName9a;
432 }
433
434 /**
435 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getDaoReferenceName()
436 * @return String
437 */
438 protected abstract String handleGetDaoReferenceName();
439
440 private String __daoReferenceName10a;
441 private boolean __daoReferenceName10aSet = false;
442
443 /**
444 * TODO: Model Documentation for
445 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.daoReferenceName
446 * @return (String)handleGetDaoReferenceName()
447 */
448 public final String getDaoReferenceName()
449 {
450 String daoReferenceName10a = this.__daoReferenceName10a;
451 if (!this.__daoReferenceName10aSet)
452 {
453 // daoReferenceName has no pre constraints
454 daoReferenceName10a = handleGetDaoReferenceName();
455 // daoReferenceName has no post constraints
456 this.__daoReferenceName10a = daoReferenceName10a;
457 if (isMetafacadePropertyCachingEnabled())
458 {
459 this.__daoReferenceName10aSet = true;
460 }
461 }
462 return daoReferenceName10a;
463 }
464
465 /**
466 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getManageableValueObjectFullPath()
467 * @return String
468 */
469 protected abstract String handleGetManageableValueObjectFullPath();
470
471 private String __manageableValueObjectFullPath11a;
472 private boolean __manageableValueObjectFullPath11aSet = false;
473
474 /**
475 * TODO: Model Documentation for
476 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.manageableValueObjectFullPath
477 * @return (String)handleGetManageableValueObjectFullPath()
478 */
479 public final String getManageableValueObjectFullPath()
480 {
481 String manageableValueObjectFullPath11a = this.__manageableValueObjectFullPath11a;
482 if (!this.__manageableValueObjectFullPath11aSet)
483 {
484 // manageableValueObjectFullPath has no pre constraints
485 manageableValueObjectFullPath11a = handleGetManageableValueObjectFullPath();
486 // manageableValueObjectFullPath has no post constraints
487 this.__manageableValueObjectFullPath11a = manageableValueObjectFullPath11a;
488 if (isMetafacadePropertyCachingEnabled())
489 {
490 this.__manageableValueObjectFullPath11aSet = true;
491 }
492 }
493 return manageableValueObjectFullPath11a;
494 }
495
496 /**
497 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getManageableValueObjectClassName()
498 * @return String
499 */
500 protected abstract String handleGetManageableValueObjectClassName();
501
502 private String __manageableValueObjectClassName12a;
503 private boolean __manageableValueObjectClassName12aSet = false;
504
505 /**
506 * TODO: Model Documentation for
507 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.manageableValueObjectClassName
508 * @return (String)handleGetManageableValueObjectClassName()
509 */
510 public final String getManageableValueObjectClassName()
511 {
512 String manageableValueObjectClassName12a = this.__manageableValueObjectClassName12a;
513 if (!this.__manageableValueObjectClassName12aSet)
514 {
515 // manageableValueObjectClassName has no pre constraints
516 manageableValueObjectClassName12a = handleGetManageableValueObjectClassName();
517 // manageableValueObjectClassName has no post constraints
518 this.__manageableValueObjectClassName12a = manageableValueObjectClassName12a;
519 if (isMetafacadePropertyCachingEnabled())
520 {
521 this.__manageableValueObjectClassName12aSet = true;
522 }
523 }
524 return manageableValueObjectClassName12a;
525 }
526
527 /**
528 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getFullyQualifiedManageableValueObjectName()
529 * @return String
530 */
531 protected abstract String handleGetFullyQualifiedManageableValueObjectName();
532
533 private String __fullyQualifiedManageableValueObjectName13a;
534 private boolean __fullyQualifiedManageableValueObjectName13aSet = false;
535
536 /**
537 * TODO: Model Documentation for
538 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.fullyQualifiedManageableValueObjectName
539 * @return (String)handleGetFullyQualifiedManageableValueObjectName()
540 */
541 public final String getFullyQualifiedManageableValueObjectName()
542 {
543 String fullyQualifiedManageableValueObjectName13a = this.__fullyQualifiedManageableValueObjectName13a;
544 if (!this.__fullyQualifiedManageableValueObjectName13aSet)
545 {
546 // fullyQualifiedManageableValueObjectName has no pre constraints
547 fullyQualifiedManageableValueObjectName13a = handleGetFullyQualifiedManageableValueObjectName();
548 // fullyQualifiedManageableValueObjectName has no post constraints
549 this.__fullyQualifiedManageableValueObjectName13a = fullyQualifiedManageableValueObjectName13a;
550 if (isMetafacadePropertyCachingEnabled())
551 {
552 this.__fullyQualifiedManageableValueObjectName13aSet = true;
553 }
554 }
555 return fullyQualifiedManageableValueObjectName13a;
556 }
557
558 /**
559 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#isRemotingTypeRmi()
560 * @return boolean
561 */
562 protected abstract boolean handleIsRemotingTypeRmi();
563
564 private boolean __remotingTypeRmi14a;
565 private boolean __remotingTypeRmi14aSet = false;
566
567 /**
568 * Indicates if the remoting type is RMI.
569 * @return (boolean)handleIsRemotingTypeRmi()
570 */
571 public final boolean isRemotingTypeRmi()
572 {
573 boolean remotingTypeRmi14a = this.__remotingTypeRmi14a;
574 if (!this.__remotingTypeRmi14aSet)
575 {
576 // remotingTypeRmi has no pre constraints
577 remotingTypeRmi14a = handleIsRemotingTypeRmi();
578 // remotingTypeRmi has no post constraints
579 this.__remotingTypeRmi14a = remotingTypeRmi14a;
580 if (isMetafacadePropertyCachingEnabled())
581 {
582 this.__remotingTypeRmi14aSet = true;
583 }
584 }
585 return remotingTypeRmi14a;
586 }
587
588 /**
589 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#isRemotingTypeNone()
590 * @return boolean
591 */
592 protected abstract boolean handleIsRemotingTypeNone();
593
594 private boolean __remotingTypeNone15a;
595 private boolean __remotingTypeNone15aSet = false;
596
597 /**
598 * Indicates if the remoting type for this service is "none".
599 * @return (boolean)handleIsRemotingTypeNone()
600 */
601 public final boolean isRemotingTypeNone()
602 {
603 boolean remotingTypeNone15a = this.__remotingTypeNone15a;
604 if (!this.__remotingTypeNone15aSet)
605 {
606 // remotingTypeNone has no pre constraints
607 remotingTypeNone15a = handleIsRemotingTypeNone();
608 // remotingTypeNone has no post constraints
609 this.__remotingTypeNone15a = remotingTypeNone15a;
610 if (isMetafacadePropertyCachingEnabled())
611 {
612 this.__remotingTypeNone15aSet = true;
613 }
614 }
615 return remotingTypeNone15a;
616 }
617
618 /**
619 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#isRemotingTypeHttpInvoker()
620 * @return boolean
621 */
622 protected abstract boolean handleIsRemotingTypeHttpInvoker();
623
624 private boolean __remotingTypeHttpInvoker16a;
625 private boolean __remotingTypeHttpInvoker16aSet = false;
626
627 /**
628 * Indicates if the remoting type is "httpinvoker".
629 * @return (boolean)handleIsRemotingTypeHttpInvoker()
630 */
631 public final boolean isRemotingTypeHttpInvoker()
632 {
633 boolean remotingTypeHttpInvoker16a = this.__remotingTypeHttpInvoker16a;
634 if (!this.__remotingTypeHttpInvoker16aSet)
635 {
636 // remotingTypeHttpInvoker has no pre constraints
637 remotingTypeHttpInvoker16a = handleIsRemotingTypeHttpInvoker();
638 // remotingTypeHttpInvoker has no post constraints
639 this.__remotingTypeHttpInvoker16a = remotingTypeHttpInvoker16a;
640 if (isMetafacadePropertyCachingEnabled())
641 {
642 this.__remotingTypeHttpInvoker16aSet = true;
643 }
644 }
645 return remotingTypeHttpInvoker16a;
646 }
647
648 /**
649 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#isRemotingTypeHessian()
650 * @return boolean
651 */
652 protected abstract boolean handleIsRemotingTypeHessian();
653
654 private boolean __remotingTypeHessian17a;
655 private boolean __remotingTypeHessian17aSet = false;
656
657 /**
658 * Indicates if the remoting type is "hessian".
659 * @return (boolean)handleIsRemotingTypeHessian()
660 */
661 public final boolean isRemotingTypeHessian()
662 {
663 boolean remotingTypeHessian17a = this.__remotingTypeHessian17a;
664 if (!this.__remotingTypeHessian17aSet)
665 {
666 // remotingTypeHessian has no pre constraints
667 remotingTypeHessian17a = handleIsRemotingTypeHessian();
668 // remotingTypeHessian has no post constraints
669 this.__remotingTypeHessian17a = remotingTypeHessian17a;
670 if (isMetafacadePropertyCachingEnabled())
671 {
672 this.__remotingTypeHessian17aSet = true;
673 }
674 }
675 return remotingTypeHessian17a;
676 }
677
678 /**
679 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#isRemotingTypeBurlap()
680 * @return boolean
681 */
682 protected abstract boolean handleIsRemotingTypeBurlap();
683
684 private boolean __remotingTypeBurlap18a;
685 private boolean __remotingTypeBurlap18aSet = false;
686
687 /**
688 * Indicates if the remoting type is "burlap".
689 * @return (boolean)handleIsRemotingTypeBurlap()
690 */
691 public final boolean isRemotingTypeBurlap()
692 {
693 boolean remotingTypeBurlap18a = this.__remotingTypeBurlap18a;
694 if (!this.__remotingTypeBurlap18aSet)
695 {
696 // remotingTypeBurlap has no pre constraints
697 remotingTypeBurlap18a = handleIsRemotingTypeBurlap();
698 // remotingTypeBurlap has no post constraints
699 this.__remotingTypeBurlap18a = remotingTypeBurlap18a;
700 if (isMetafacadePropertyCachingEnabled())
701 {
702 this.__remotingTypeBurlap18aSet = true;
703 }
704 }
705 return remotingTypeBurlap18a;
706 }
707
708 /**
709 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getRemoteUrl()
710 * @return String
711 */
712 protected abstract String handleGetRemoteUrl();
713
714 private String __remoteUrl19a;
715 private boolean __remoteUrl19aSet = false;
716
717 /**
718 * The URL this servie will be run on at the server side.
719 * @return (String)handleGetRemoteUrl()
720 */
721 public final String getRemoteUrl()
722 {
723 String remoteUrl19a = this.__remoteUrl19a;
724 if (!this.__remoteUrl19aSet)
725 {
726 // remoteUrl has no pre constraints
727 remoteUrl19a = handleGetRemoteUrl();
728 // remoteUrl has no post constraints
729 this.__remoteUrl19a = remoteUrl19a;
730 if (isMetafacadePropertyCachingEnabled())
731 {
732 this.__remoteUrl19aSet = true;
733 }
734 }
735 return remoteUrl19a;
736 }
737
738 /**
739 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getRemoteServer()
740 * @return String
741 */
742 protected abstract String handleGetRemoteServer();
743
744 private String __remoteServer20a;
745 private boolean __remoteServer20aSet = false;
746
747 /**
748 * Returns the name of the remote server for this service.
749 * @return (String)handleGetRemoteServer()
750 */
751 public final String getRemoteServer()
752 {
753 String remoteServer20a = this.__remoteServer20a;
754 if (!this.__remoteServer20aSet)
755 {
756 // remoteServer has no pre constraints
757 remoteServer20a = handleGetRemoteServer();
758 // remoteServer has no post constraints
759 this.__remoteServer20a = remoteServer20a;
760 if (isMetafacadePropertyCachingEnabled())
761 {
762 this.__remoteServer20aSet = true;
763 }
764 }
765 return remoteServer20a;
766 }
767
768 /**
769 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getRemotePort()
770 * @return String
771 */
772 protected abstract String handleGetRemotePort();
773
774 private String __remotePort21a;
775 private boolean __remotePort21aSet = false;
776
777 /**
778 * Determines which port this service will be published on at the server side.
779 * @return (String)handleGetRemotePort()
780 */
781 public final String getRemotePort()
782 {
783 String remotePort21a = this.__remotePort21a;
784 if (!this.__remotePort21aSet)
785 {
786 // remotePort has no pre constraints
787 remotePort21a = handleGetRemotePort();
788 // remotePort has no post constraints
789 this.__remotePort21a = remotePort21a;
790 if (isMetafacadePropertyCachingEnabled())
791 {
792 this.__remotePort21aSet = true;
793 }
794 }
795 return remotePort21a;
796 }
797
798 /**
799 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getRemoteContext()
800 * @return String
801 */
802 protected abstract String handleGetRemoteContext();
803
804 private String __remoteContext22a;
805 private boolean __remoteContext22aSet = false;
806
807 /**
808 * Returns the remote context for this service.
809 * @return (String)handleGetRemoteContext()
810 */
811 public final String getRemoteContext()
812 {
813 String remoteContext22a = this.__remoteContext22a;
814 if (!this.__remoteContext22aSet)
815 {
816 // remoteContext has no pre constraints
817 remoteContext22a = handleGetRemoteContext();
818 // remoteContext has no post constraints
819 this.__remoteContext22a = remoteContext22a;
820 if (isMetafacadePropertyCachingEnabled())
821 {
822 this.__remoteContext22aSet = true;
823 }
824 }
825 return remoteContext22a;
826 }
827
828 /**
829 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#isRemotable()
830 * @return boolean
831 */
832 protected abstract boolean handleIsRemotable();
833
834 private boolean __remotable23a;
835 private boolean __remotable23aSet = false;
836
837 /**
838 * Returns true if this service is remotable. Derived from remotingType.
839 * @return (boolean)handleIsRemotable()
840 */
841 public final boolean isRemotable()
842 {
843 boolean remotable23a = this.__remotable23a;
844 if (!this.__remotable23aSet)
845 {
846 // remotable has no pre constraints
847 remotable23a = handleIsRemotable();
848 // remotable has no post constraints
849 this.__remotable23a = remotable23a;
850 if (isMetafacadePropertyCachingEnabled())
851 {
852 this.__remotable23aSet = true;
853 }
854 }
855 return remotable23a;
856 }
857
858 /**
859 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getManageableSearchExampleFullPath()
860 * @return String
861 */
862 protected abstract String handleGetManageableSearchExampleFullPath();
863
864 private String __manageableSearchExampleFullPath24a;
865 private boolean __manageableSearchExampleFullPath24aSet = false;
866
867 /**
868 * TODO: Model Documentation for
869 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.manageableSearchExampleFullPath
870 * @return (String)handleGetManageableSearchExampleFullPath()
871 */
872 public final String getManageableSearchExampleFullPath()
873 {
874 String manageableSearchExampleFullPath24a = this.__manageableSearchExampleFullPath24a;
875 if (!this.__manageableSearchExampleFullPath24aSet)
876 {
877 // manageableSearchExampleFullPath has no pre constraints
878 manageableSearchExampleFullPath24a = handleGetManageableSearchExampleFullPath();
879 // manageableSearchExampleFullPath has no post constraints
880 this.__manageableSearchExampleFullPath24a = manageableSearchExampleFullPath24a;
881 if (isMetafacadePropertyCachingEnabled())
882 {
883 this.__manageableSearchExampleFullPath24aSet = true;
884 }
885 }
886 return manageableSearchExampleFullPath24a;
887 }
888
889 /**
890 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getManageableSearchExampleClassName()
891 * @return String
892 */
893 protected abstract String handleGetManageableSearchExampleClassName();
894
895 private String __manageableSearchExampleClassName25a;
896 private boolean __manageableSearchExampleClassName25aSet = false;
897
898 /**
899 * TODO: Model Documentation for
900 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.manageableSearchExampleClassName
901 * @return (String)handleGetManageableSearchExampleClassName()
902 */
903 public final String getManageableSearchExampleClassName()
904 {
905 String manageableSearchExampleClassName25a = this.__manageableSearchExampleClassName25a;
906 if (!this.__manageableSearchExampleClassName25aSet)
907 {
908 // manageableSearchExampleClassName has no pre constraints
909 manageableSearchExampleClassName25a = handleGetManageableSearchExampleClassName();
910 // manageableSearchExampleClassName has no post constraints
911 this.__manageableSearchExampleClassName25a = manageableSearchExampleClassName25a;
912 if (isMetafacadePropertyCachingEnabled())
913 {
914 this.__manageableSearchExampleClassName25aSet = true;
915 }
916 }
917 return manageableSearchExampleClassName25a;
918 }
919
920 /**
921 * @see org.andromda.cartridges.spring.metafacades.SpringManageableEntity#getFullyQualifiedManageableSearchExampleName()
922 * @return String
923 */
924 protected abstract String handleGetFullyQualifiedManageableSearchExampleName();
925
926 private String __fullyQualifiedManageableSearchExampleName26a;
927 private boolean __fullyQualifiedManageableSearchExampleName26aSet = false;
928
929 /**
930 * TODO: Model Documentation for
931 * org.andromda.cartridges.spring.metafacades.SpringManageableEntity.fullyQualifiedManageableSearchExampleName
932 * @return (String)handleGetFullyQualifiedManageableSearchExampleName()
933 */
934 public final String getFullyQualifiedManageableSearchExampleName()
935 {
936 String fullyQualifiedManageableSearchExampleName26a = this.__fullyQualifiedManageableSearchExampleName26a;
937 if (!this.__fullyQualifiedManageableSearchExampleName26aSet)
938 {
939 // fullyQualifiedManageableSearchExampleName has no pre constraints
940 fullyQualifiedManageableSearchExampleName26a = handleGetFullyQualifiedManageableSearchExampleName();
941 // fullyQualifiedManageableSearchExampleName has no post constraints
942 this.__fullyQualifiedManageableSearchExampleName26a = fullyQualifiedManageableSearchExampleName26a;
943 if (isMetafacadePropertyCachingEnabled())
944 {
945 this.__fullyQualifiedManageableSearchExampleName26aSet = true;
946 }
947 }
948 return fullyQualifiedManageableSearchExampleName26a;
949 }
950
951 /**
952 * @return true
953 * @see SpringEntity
954 */
955 public boolean isSpringEntityMetaType()
956 {
957 return true;
958 }
959
960 /**
961 * @return true
962 * @see ManageableEntity
963 */
964 public boolean isManageableEntityMetaType()
965 {
966 return true;
967 }
968
969 /**
970 * @return true
971 * @see org.andromda.metafacades.uml.Entity
972 */
973 public boolean isEntityMetaType()
974 {
975 return true;
976 }
977
978 /**
979 * @return true
980 * @see ClassifierFacade
981 */
982 public boolean isClassifierFacadeMetaType()
983 {
984 return true;
985 }
986
987 /**
988 * @return true
989 * @see GeneralizableElementFacade
990 */
991 public boolean isGeneralizableElementFacadeMetaType()
992 {
993 return true;
994 }
995
996 /**
997 * @return true
998 * @see ModelElementFacade
999 */
1000 public boolean isModelElementFacadeMetaType()
1001 {
1002 return true;
1003 }
1004
1005 // ----------- delegates to SpringEntity ------------
1006 /**
1007 * Returns all value object references (this includes all those that are inherited from any
1008 * parent entities)
1009 * @see SpringEntity#getAllValueObjectReferences()
1010 */
1011 public Collection<ClassifierFacade> getAllValueObjectReferences()
1012 {
1013 return this.getSuperSpringEntity().getAllValueObjectReferences();
1014 }
1015
1016 /**
1017 * A quoted comma separated list of the names of embedded values belonging to this entity (that
1018 * represented as attributes)
1019 * @see SpringEntity#getAttributeEmbeddedValueList()
1020 */
1021 public String getAttributeEmbeddedValueList()
1022 {
1023 return this.getSuperSpringEntity().getAttributeEmbeddedValueList();
1024 }
1025
1026 /**
1027 * Gets the Spring bean name, and optionally adds a target suffix, if 'targetSuffix' is set to
1028 * true.
1029 * @see SpringEntity#getBeanName(boolean targetSuffix)
1030 */
1031 public String getBeanName(boolean targetSuffix)
1032 {
1033 return this.getSuperSpringEntity().getBeanName(targetSuffix);
1034 }
1035
1036 /**
1037 * The DAO base class name. This is the abstract DAO that contains CRUD operations
1038 * as well as any generated finders defined on an entity.
1039 * @see SpringEntity#getDaoBaseName()
1040 */
1041 public String getDaoBaseName()
1042 {
1043 return this.getSuperSpringEntity().getDaoBaseName();
1044 }
1045
1046 /**
1047 * The business operations modeled on the entity that will be generated on the DAO (Data Access
1048 * Object).
1049 * @see SpringEntity#getDaoBusinessOperations()
1050 */
1051 public Collection<SpringEntityOperation> getDaoBusinessOperations()
1052 {
1053 return this.getSuperSpringEntity().getDaoBusinessOperations();
1054 }
1055
1056 /**
1057 * The DAO implementation class name.
1058 * @see SpringEntity#getDaoImplementationName()
1059 */
1060 public String getDaoImplementationName()
1061 {
1062 return this.getSuperSpringEntity().getDaoImplementationName();
1063 }
1064
1065 /**
1066 * The name of the DAO for the specified entity.
1067 * @see SpringEntity#getDaoName()
1068 */
1069 public String getDaoName()
1070 {
1071 return this.getSuperSpringEntity().getDaoName();
1072 }
1073
1074 /**
1075 * The constant name denoting no transformation is to be applied.
1076 * @see SpringEntity#getDaoNoTransformationConstantName()
1077 */
1078 public String getDaoNoTransformationConstantName()
1079 {
1080 return this.getSuperSpringEntity().getDaoNoTransformationConstantName();
1081 }
1082
1083 /**
1084 * The implementation name for the entity.
1085 * @see SpringEntity#getEntityImplementationName()
1086 */
1087 public String getEntityImplementationName()
1088 {
1089 return this.getSuperSpringEntity().getEntityImplementationName();
1090 }
1091
1092 /**
1093 * The name of the plain entity name.
1094 * @see SpringEntity#getEntityName()
1095 */
1096 public String getEntityName()
1097 {
1098 return this.getSuperSpringEntity().getEntityName();
1099 }
1100
1101 /**
1102 * The fully qualified name of the base DAO.
1103 * @see SpringEntity#getFullyQualifiedDaoBaseName()
1104 */
1105 public String getFullyQualifiedDaoBaseName()
1106 {
1107 return this.getSuperSpringEntity().getFullyQualifiedDaoBaseName();
1108 }
1109
1110 /**
1111 * The fully qualified name of the DAO implemetation.
1112 * @see SpringEntity#getFullyQualifiedDaoImplementationName()
1113 */
1114 public String getFullyQualifiedDaoImplementationName()
1115 {
1116 return this.getSuperSpringEntity().getFullyQualifiedDaoImplementationName();
1117 }
1118
1119 /**
1120 * The fully qualified name of the DAO.
1121 * @see SpringEntity#getFullyQualifiedDaoName()
1122 */
1123 public String getFullyQualifiedDaoName()
1124 {
1125 return this.getSuperSpringEntity().getFullyQualifiedDaoName();
1126 }
1127
1128 /**
1129 * The fully qualified name of the entity implementation class.
1130 * @see SpringEntity#getFullyQualifiedEntityImplementationName()
1131 */
1132 public String getFullyQualifiedEntityImplementationName()
1133 {
1134 return this.getSuperSpringEntity().getFullyQualifiedEntityImplementationName();
1135 }
1136
1137 /**
1138 * The fully qualified name of the entity class.
1139 * @see SpringEntity#getFullyQualifiedEntityName()
1140 */
1141 public String getFullyQualifiedEntityName()
1142 {
1143 return this.getSuperSpringEntity().getFullyQualifiedEntityName();
1144 }
1145
1146 /**
1147 * Return the value of the tagged value andromda_hibernate_inheritance.
1148 * @see SpringEntity#getHibernateInheritanceStrategy()
1149 */
1150 public String getHibernateInheritanceStrategy()
1151 {
1152 return this.getSuperSpringEntity().getHibernateInheritanceStrategy();
1153 }
1154
1155 /**
1156 * Travels up the inheritance hierarchy and retrieves the root of this entity. If the root is
1157 * the entity itself then just the entity is returned.
1158 * @see SpringEntity#getRoot()
1159 */
1160 public SpringEntity getRoot()
1161 {
1162 return this.getSuperSpringEntity().getRoot();
1163 }
1164
1165 /**
1166 * A Classifier is a classification of instances - it describes a set of instances that have
1167 * features
1168 * in common. Can specify a generalization hierarchy by referencing its general classifiers. It
1169 * may be
1170 * a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
1171 * generalization hierarchy by referencing its general classifiers. Has the capability to own
1172 * collaboration uses. These collaboration uses link a collaboration with the classifier to give
1173 * a
1174 * description of the workings of the classifier. Classifier is defined to be a kind of
1175 * templateable
1176 * element so that a classifier can be parameterized. It is also defined to be a kind of
1177 * parameterable
1178 * element so that a classifier can be a formal template parameter.
1179 * @see SpringEntity#getValueObjectReferences()
1180 */
1181 public Collection<ClassifierFacade> getValueObjectReferences()
1182 {
1183 return this.getSuperSpringEntity().getValueObjectReferences();
1184 }
1185
1186 /**
1187 * Indicates whether or not any business DAO operations are present.
1188 * @see SpringEntity#isDaoBusinessOperationsPresent()
1189 */
1190 public boolean isDaoBusinessOperationsPresent()
1191 {
1192 return this.getSuperSpringEntity().isDaoBusinessOperationsPresent();
1193 }
1194
1195 /**
1196 * True if an implementation is required for the dao class, this is the case when there are
1197 * business operations or value-object transformation.
1198 * @see SpringEntity#isDaoImplementationRequired()
1199 */
1200 public boolean isDaoImplementationRequired()
1201 {
1202 return this.getSuperSpringEntity().isDaoImplementationRequired();
1203 }
1204
1205 /**
1206 * Return true if the hibernate inheritance strategy is class.
1207 * @see SpringEntity#isHibernateInheritanceClass()
1208 */
1209 public boolean isHibernateInheritanceClass()
1210 {
1211 return this.getSuperSpringEntity().isHibernateInheritanceClass();
1212 }
1213
1214 /**
1215 * Return true if the hibernate inheritance strategy is concrete.
1216 * @see SpringEntity#isHibernateInheritanceConcrete()
1217 */
1218 public boolean isHibernateInheritanceConcrete()
1219 {
1220 return this.getSuperSpringEntity().isHibernateInheritanceConcrete();
1221 }
1222
1223 /**
1224 * Return true if the hibernate inheritance strategy is interface.
1225 * @see SpringEntity#isHibernateInheritanceInterface()
1226 */
1227 public boolean isHibernateInheritanceInterface()
1228 {
1229 return this.getSuperSpringEntity().isHibernateInheritanceInterface();
1230 }
1231
1232 /**
1233 * Return true if the hibernate inheritance strategy is subclass.
1234 * @see SpringEntity#isHibernateInheritanceSubclass()
1235 */
1236 public boolean isHibernateInheritanceSubclass()
1237 {
1238 return this.getSuperSpringEntity().isHibernateInheritanceSubclass();
1239 }
1240
1241 /**
1242 * Indicates whether or not this entity requires a Hibernate mapping cfg.xml file within the
1243 * Spring application context.
1244 * @see SpringEntity#isRequiresHibernateMapping()
1245 */
1246 public boolean isRequiresHibernateMapping()
1247 {
1248 return this.getSuperSpringEntity().isRequiresHibernateMapping();
1249 }
1250
1251 /**
1252 * Returns true if this entity is meant to be used in a richt client application.
1253 * @see SpringEntity#isRichClient()
1254 */
1255 public boolean isRichClient()
1256 {
1257 return this.getSuperSpringEntity().isRichClient();
1258 }
1259
1260 /**
1261 * Return the attribute which name matches the parameter
1262 * @see ClassifierFacade#findAttribute(String name)
1263 */
1264 public AttributeFacade findAttribute(String name)
1265 {
1266 return this.getSuperSpringEntity().findAttribute(name);
1267 }
1268
1269 /**
1270 * Those abstraction dependencies for which this classifier is the client.
1271 * @see ClassifierFacade#getAbstractions()
1272 */
1273 public Collection<ClassifierFacade> getAbstractions()
1274 {
1275 return this.getSuperSpringEntity().getAbstractions();
1276 }
1277
1278 /**
1279 * Lists all classes associated to this one and any ancestor classes (through generalization).
1280 * There will be no duplicates. The order of the elements is predictable.
1281 * @see ClassifierFacade#getAllAssociatedClasses()
1282 */
1283 public Collection<ClassifierFacade> getAllAssociatedClasses()
1284 {
1285 return this.getSuperSpringEntity().getAllAssociatedClasses();
1286 }
1287
1288 /**
1289 * A collection containing all 'properties' of the classifier and its ancestors. Properties are
1290 * any attributes and navigable connecting association ends.
1291 * @see ClassifierFacade#getAllProperties()
1292 */
1293 public Collection<ModelElementFacade> getAllProperties()
1294 {
1295 return this.getSuperSpringEntity().getAllProperties();
1296 }
1297
1298 /**
1299 * A collection containing all required and/or read-only 'properties' of the classifier and its
1300 * ancestors. Properties are any attributes and navigable connecting association ends.
1301 * @see ClassifierFacade#getAllRequiredConstructorParameters()
1302 */
1303 public Collection<ModelElementFacade> getAllRequiredConstructorParameters()
1304 {
1305 return this.getSuperSpringEntity().getAllRequiredConstructorParameters();
1306 }
1307
1308 /**
1309 * Gets the array type for this classifier. If this classifier already represents an array, it
1310 * just returns itself.
1311 * @see ClassifierFacade#getArray()
1312 */
1313 public ClassifierFacade getArray()
1314 {
1315 return this.getSuperSpringEntity().getArray();
1316 }
1317
1318 /**
1319 * The name of the classifier as an array.
1320 * @see ClassifierFacade#getArrayName()
1321 */
1322 public String getArrayName()
1323 {
1324 return this.getSuperSpringEntity().getArrayName();
1325 }
1326
1327 /**
1328 * Lists the classes associated to this one, there is no repitition of classes. The order of the
1329 * elements is predictable.
1330 * @see ClassifierFacade#getAssociatedClasses()
1331 */
1332 public Collection<ClassifierFacade> getAssociatedClasses()
1333 {
1334 return this.getSuperSpringEntity().getAssociatedClasses();
1335 }
1336
1337 /**
1338 * Gets the association ends belonging to a classifier.
1339 * @see ClassifierFacade#getAssociationEnds()
1340 */
1341 public List<AssociationEndFacade> getAssociationEnds()
1342 {
1343 return this.getSuperSpringEntity().getAssociationEnds();
1344 }
1345
1346 /**
1347 * Gets the attributes that belong to the classifier.
1348 * @see ClassifierFacade#getAttributes()
1349 */
1350 public List<AttributeFacade> getAttributes()
1351 {
1352 return this.getSuperSpringEntity().getAttributes();
1353 }
1354
1355 /**
1356 * Gets all attributes for the classifier and if 'follow' is true goes up the inheritance
1357 * hierarchy and gets the attributes from the super classes as well.
1358 * @see ClassifierFacade#getAttributes(boolean follow)
1359 */
1360 public List<AttributeFacade> getAttributes(boolean follow)
1361 {
1362 return this.getSuperSpringEntity().getAttributes(follow);
1363 }
1364
1365 /**
1366 * The fully qualified name of the classifier as an array.
1367 * @see ClassifierFacade#getFullyQualifiedArrayName()
1368 */
1369 public String getFullyQualifiedArrayName()
1370 {
1371 return this.getSuperSpringEntity().getFullyQualifiedArrayName();
1372 }
1373
1374 /**
1375 * Returns all those operations that could be implemented at this classifier's level. This means
1376 * the operations owned by this classifier as well as any realized interface's operations
1377 * (recursively) in case this classifier itself is not already an interface, or generalized when
1378 * this classifier is an interface.
1379 * @see ClassifierFacade#getImplementationOperations()
1380 */
1381 public Collection<OperationFacade> getImplementationOperations()
1382 {
1383 return this.getSuperSpringEntity().getImplementationOperations();
1384 }
1385
1386 /**
1387 * A comma separated list of the fully qualified names of all implemented interfaces.
1388 * @see ClassifierFacade#getImplementedInterfaceList()
1389 */
1390 public String getImplementedInterfaceList()
1391 {
1392 return this.getSuperSpringEntity().getImplementedInterfaceList();
1393 }
1394
1395 /**
1396 * Those attributes that are scoped to an instance of this class.
1397 * @see ClassifierFacade#getInstanceAttributes()
1398 */
1399 public Collection<AttributeFacade> getInstanceAttributes()
1400 {
1401 return this.getSuperSpringEntity().getInstanceAttributes();
1402 }
1403
1404 /**
1405 * Those operations that are scoped to an instance of this class.
1406 * @see ClassifierFacade#getInstanceOperations()
1407 */
1408 public List<OperationFacade> getInstanceOperations()
1409 {
1410 return this.getSuperSpringEntity().getInstanceOperations();
1411 }
1412
1413 /**
1414 * Those interfaces that are abstractions of this classifier, this basically means this
1415 * classifier realizes them.
1416 * @see ClassifierFacade#getInterfaceAbstractions()
1417 */
1418 public Collection<ClassifierFacade> getInterfaceAbstractions()
1419 {
1420 return this.getSuperSpringEntity().getInterfaceAbstractions();
1421 }
1422
1423 /**
1424 * A String representing a new Constructor declaration for this classifier type to be used in a
1425 * Java environment.
1426 * @see ClassifierFacade#getJavaNewString()
1427 */
1428 public String getJavaNewString()
1429 {
1430 return this.getSuperSpringEntity().getJavaNewString();
1431 }
1432
1433 /**
1434 * A String representing the null-value for this classifier type to be used in a Java
1435 * environment.
1436 * @see ClassifierFacade#getJavaNullString()
1437 */
1438 public String getJavaNullString()
1439 {
1440 return this.getSuperSpringEntity().getJavaNullString();
1441 }
1442
1443 /**
1444 * The other ends of this classifier's association ends which are navigable.
1445 * @see ClassifierFacade#getNavigableConnectingEnds()
1446 */
1447 public Collection<AssociationEndFacade> getNavigableConnectingEnds()
1448 {
1449 return this.getSuperSpringEntity().getNavigableConnectingEnds();
1450 }
1451
1452 /**
1453 * Get the other ends of this classifier's association ends which are navigable and if 'follow'
1454 * is true goes up the inheritance hierarchy and gets the super association ends as well.
1455 * @see ClassifierFacade#getNavigableConnectingEnds(boolean follow)
1456 */
1457 public List<AssociationEndFacade> getNavigableConnectingEnds(boolean follow)
1458 {
1459 return this.getSuperSpringEntity().getNavigableConnectingEnds(follow);
1460 }
1461
1462 /**
1463 * Assuming that the classifier is an array, this will return the non array type of the
1464 * classifier from
1465 * the model. If the classifier is NOT an array, it will just return itself.
1466 * @see ClassifierFacade#getNonArray()
1467 */
1468 public ClassifierFacade getNonArray()
1469 {
1470 return this.getSuperSpringEntity().getNonArray();
1471 }
1472
1473 /**
1474 * The attributes from this classifier in the form of an operation call (this example would be
1475 * in Java): '(String attributeOne, String attributeTwo). If there were no attributes on the
1476 * classifier, the result would be an empty '()'.
1477 * @see ClassifierFacade#getOperationCallFromAttributes()
1478 */
1479 public String getOperationCallFromAttributes()
1480 {
1481 return this.getSuperSpringEntity().getOperationCallFromAttributes();
1482 }
1483
1484 /**
1485 * The operations owned by this classifier.
1486 * @see ClassifierFacade#getOperations()
1487 */
1488 public List<OperationFacade> getOperations()
1489 {
1490 return this.getSuperSpringEntity().getOperations();
1491 }
1492
1493 /**
1494 * A collection containing all 'properties' of the classifier. Properties are any attributes
1495 * and navigable connecting association ends.
1496 * @see ClassifierFacade#getProperties()
1497 */
1498 public List<ModelElementFacade> getProperties()
1499 {
1500 return this.getSuperSpringEntity().getProperties();
1501 }
1502
1503 /**
1504 * Gets all properties (attributes and navigable association ends) for the classifier and if
1505 * 'follow' is true goes up the inheritance hierarchy and gets the properties from the super
1506 * classes as well.
1507 * @see ClassifierFacade#getProperties(boolean follow)
1508 */
1509 public List getProperties(boolean follow)
1510 {
1511 return this.getSuperSpringEntity().getProperties(follow);
1512 }
1513
1514 /**
1515 * A collection containing all required and/or read-only 'properties' of the classifier.
1516 * Properties are any attributes and navigable connecting association ends.
1517 * @see ClassifierFacade#getRequiredConstructorParameters()
1518 */
1519 public Collection<ModelElementFacade> getRequiredConstructorParameters()
1520 {
1521 return this.getSuperSpringEntity().getRequiredConstructorParameters();
1522 }
1523
1524 /**
1525 * Returns the serial version UID of the underlying model element.
1526 * @see ClassifierFacade#getSerialVersionUID()
1527 */
1528 public long getSerialVersionUID()
1529 {
1530 return this.getSuperSpringEntity().getSerialVersionUID();
1531 }
1532
1533 /**
1534 * Those attributes that are scoped to the definition of this class.
1535 * @see ClassifierFacade#getStaticAttributes()
1536 */
1537 public Collection<AttributeFacade> getStaticAttributes()
1538 {
1539 return this.getSuperSpringEntity().getStaticAttributes();
1540 }
1541
1542 /**
1543 * Those operations that are scoped to the definition of this class.
1544 * @see ClassifierFacade#getStaticOperations()
1545 */
1546 public List<OperationFacade> getStaticOperations()
1547 {
1548 return this.getSuperSpringEntity().getStaticOperations();
1549 }
1550
1551 /**
1552 * This class' superclass, returns the generalization if it is a ClassifierFacade, null
1553 * otherwise.
1554 * @see ClassifierFacade#getSuperClass()
1555 */
1556 public ClassifierFacade getSuperClass()
1557 {
1558 return this.getSuperSpringEntity().getSuperClass();
1559 }
1560
1561 /**
1562 * The wrapper name for this classifier if a mapped type has a defined wrapper class (ie. 'long'
1563 * maps to 'Long'). If the classifier doesn't have a wrapper defined for it, this method will
1564 * return a null. Note that wrapper mappings must be defined for the namespace by defining the
1565 * 'wrapperMappingsUri', this property must point to the location of the mappings file which
1566 * maps the primitives to wrapper types.
1567 * @see ClassifierFacade#getWrapperName()
1568 */
1569 public String getWrapperName()
1570 {
1571 return this.getSuperSpringEntity().getWrapperName();
1572 }
1573
1574 /**
1575 * Indicates if this classifier is 'abstract'.
1576 * @see ClassifierFacade#isAbstract()
1577 */
1578 public boolean isAbstract()
1579 {
1580 return this.getSuperSpringEntity().isAbstract();
1581 }
1582
1583 /**
1584 * True if this classifier represents an array type. False otherwise.
1585 * @see ClassifierFacade#isArrayType()
1586 */
1587 public boolean isArrayType()
1588 {
1589 return this.getSuperSpringEntity().isArrayType();
1590 }
1591
1592 /**
1593 * True if the ClassifierFacade is an AssociationClass.
1594 * @see ClassifierFacade#isAssociationClass()
1595 */
1596 public boolean isAssociationClass()
1597 {
1598 return this.getSuperSpringEntity().isAssociationClass();
1599 }
1600
1601 /**
1602 * Returns true if this type represents a Blob type.
1603 * @see ClassifierFacade#isBlobType()
1604 */
1605 public boolean isBlobType()
1606 {
1607 return this.getSuperSpringEntity().isBlobType();
1608 }
1609
1610 /**
1611 * Indicates if this type represents a boolean type or not.
1612 * @see ClassifierFacade#isBooleanType()
1613 */
1614 public boolean isBooleanType()
1615 {
1616 return this.getSuperSpringEntity().isBooleanType();
1617 }
1618
1619 /**
1620 * Indicates if this type represents a char, Character, or java.lang.Character type or not.
1621 * @see ClassifierFacade#isCharacterType()
1622 */
1623 public boolean isCharacterType()
1624 {
1625 return this.getSuperSpringEntity().isCharacterType();
1626 }
1627
1628 /**
1629 * Returns true if this type represents a Clob type.
1630 * @see ClassifierFacade#isClobType()
1631 */
1632 public boolean isClobType()
1633 {
1634 return this.getSuperSpringEntity().isClobType();
1635 }
1636
1637 /**
1638 * True if this classifier represents a collection type. False otherwise.
1639 * @see ClassifierFacade#isCollectionType()
1640 */
1641 public boolean isCollectionType()
1642 {
1643 return this.getSuperSpringEntity().isCollectionType();
1644 }
1645
1646 /**
1647 * True/false depending on whether or not this classifier represents a datatype. A data type is
1648 * a type whose instances are identified only by their value. A data type may contain attributes
1649 * to support the modeling of structured data types.
1650 * @see ClassifierFacade#isDataType()
1651 */
1652 public boolean isDataType()
1653 {
1654 return this.getSuperSpringEntity().isDataType();
1655 }
1656
1657 /**
1658 * True when this classifier is a date type.
1659 * @see ClassifierFacade#isDateType()
1660 */
1661 public boolean isDateType()
1662 {
1663 return this.getSuperSpringEntity().isDateType();
1664 }
1665
1666 /**
1667 * Indicates if this type represents a Double type or not.
1668 * @see ClassifierFacade#isDoubleType()
1669 */
1670 public boolean isDoubleType()
1671 {
1672 return this.getSuperSpringEntity().isDoubleType();
1673 }
1674
1675 /**
1676 * Indicates whether or not this classifier represents an "EmbeddedValue'.
1677 * @see ClassifierFacade#isEmbeddedValue()
1678 */
1679 public boolean isEmbeddedValue()
1680 {
1681 return this.getSuperSpringEntity().isEmbeddedValue();
1682 }
1683
1684 /**
1685 * True if this classifier is in fact marked as an enumeration.
1686 * @see ClassifierFacade#isEnumeration()
1687 */
1688 public boolean isEnumeration()
1689 {
1690 return this.getSuperSpringEntity().isEnumeration();
1691 }
1692
1693 /**
1694 * Returns true if this type represents a 'file' type.
1695 * @see ClassifierFacade#isFileType()
1696 */
1697 public boolean isFileType()
1698 {
1699 return this.getSuperSpringEntity().isFileType();
1700 }
1701
1702 /**
1703 * Indicates if this type represents a Float type or not.
1704 * @see ClassifierFacade#isFloatType()
1705 */
1706 public boolean isFloatType()
1707 {
1708 return this.getSuperSpringEntity().isFloatType();
1709 }
1710
1711 /**
1712 * Indicates if this type represents an int or Integer or java.lang.Integer type or not.
1713 * @see ClassifierFacade#isIntegerType()
1714 */
1715 public boolean isIntegerType()
1716 {
1717 return this.getSuperSpringEntity().isIntegerType();
1718 }
1719
1720 /**
1721 * True/false depending on whether or not this Classifier represents an interface.
1722 * @see ClassifierFacade#isInterface()
1723 */
1724 public boolean isInterface()
1725 {
1726 return this.getSuperSpringEntity().isInterface();
1727 }
1728
1729 /**
1730 * True if this classifier cannot be extended and represent a leaf in the inheritance tree.
1731 * @see ClassifierFacade#isLeaf()
1732 */
1733 public boolean isLeaf()
1734 {
1735 return this.getSuperSpringEntity().isLeaf();
1736 }
1737
1738 /**
1739 * True if this classifier represents a list type. False otherwise.
1740 * @see ClassifierFacade#isListType()
1741 */
1742 public boolean isListType()
1743 {
1744 return this.getSuperSpringEntity().isListType();
1745 }
1746
1747 /**
1748 * Indicates if this type represents a Long type or not.
1749 * @see ClassifierFacade#isLongType()
1750 */
1751 public boolean isLongType()
1752 {
1753 return this.getSuperSpringEntity().isLongType();
1754 }
1755
1756 /**
1757 * Indicates whether or not this classifier represents a Map type.
1758 * @see ClassifierFacade#isMapType()
1759 */
1760 public boolean isMapType()
1761 {
1762 return this.getSuperSpringEntity().isMapType();
1763 }
1764
1765 /**
1766 * Indicates whether or not this classifier represents a primitive type.
1767 * @see ClassifierFacade#isPrimitive()
1768 */
1769 public boolean isPrimitive()
1770 {
1771 return this.getSuperSpringEntity().isPrimitive();
1772 }
1773
1774 /**
1775 * True if this classifier represents a set type. False otherwise.
1776 * @see ClassifierFacade#isSetType()
1777 */
1778 public boolean isSetType()
1779 {
1780 return this.getSuperSpringEntity().isSetType();
1781 }
1782
1783 /**
1784 * Indicates whether or not this classifier represents a string type.
1785 * @see ClassifierFacade#isStringType()
1786 */
1787 public boolean isStringType()
1788 {
1789 return this.getSuperSpringEntity().isStringType();
1790 }
1791
1792 /**
1793 * Indicates whether or not this classifier represents a time type.
1794 * @see ClassifierFacade#isTimeType()
1795 */
1796 public boolean isTimeType()
1797 {
1798 return this.getSuperSpringEntity().isTimeType();
1799 }
1800
1801 /**
1802 * Returns true if this type is a wrapped primitive type.
1803 * @see ClassifierFacade#isWrappedPrimitive()
1804 */
1805 public boolean isWrappedPrimitive()
1806 {
1807 return this.getSuperSpringEntity().isWrappedPrimitive();
1808 }
1809
1810 /**
1811 * Returns a collection of all entities this entity and its ancestors have a relation to.
1812 * @see org.andromda.metafacades.uml.Entity#getAllEntityReferences()
1813 */
1814 public Collection<DependencyFacade> getAllEntityReferences()
1815 {
1816 return this.getSuperSpringEntity().getAllEntityReferences();
1817 }
1818
1819 /**
1820 * Gets a comma separated list of attribute names. If 'follow' is true, will travel up the
1821 * inheritance hiearchy to include attributes in parent entities as well. If 'withIdentifiers'
1822 * is true, will include identifiers.
1823 * @see org.andromda.metafacades.uml.Entity#getAttributeNameList(boolean follow, boolean withIdentifiers)
1824 */
1825 public String getAttributeNameList(boolean follow, boolean withIdentifiers)
1826 {
1827 return this.getSuperSpringEntity().getAttributeNameList(follow, withIdentifiers);
1828 }
1829
1830 /**
1831 * Gets a comma separated list of attribute names. If 'follow' is true, will travel up the
1832 * inheritance hiearchy to include attributes in parent entities as well. If 'withIdentifiers'
1833 * is true, will include identifiers and if 'withDerived' is set to true, will include derived
1834 * attributes.
1835 * @see org.andromda.metafacades.uml.Entity#getAttributeNameList(boolean follow, boolean withIdentifiers, boolean withDerived)
1836 */
1837 public String getAttributeNameList(boolean follow, boolean withIdentifiers, boolean withDerived)
1838 {
1839 return this.getSuperSpringEntity().getAttributeNameList(follow, withIdentifiers, withDerived);
1840 }
1841
1842 /**
1843 * Gets a comma separated list of attribute types. If 'follow' is true, will travel up the
1844 * inheritance hierarchy to include attributes in parent entities as well. If 'withIdentifiers'
1845 * is true, will include identifiers.
1846 * @see org.andromda.metafacades.uml.Entity#getAttributeTypeList(boolean follow, boolean withIdentifiers)
1847 */
1848 public String getAttributeTypeList(boolean follow, boolean withIdentifiers)
1849 {
1850 return this.getSuperSpringEntity().getAttributeTypeList(follow, withIdentifiers);
1851 }
1852
1853 /**
1854 * Gets all attributes of the entity, and optionally retieves the super entities attributes as
1855 * well as excludes the entity's identifiers if 'withIdentifiers' is set to false.
1856 * @see org.andromda.metafacades.uml.Entity#getAttributes(boolean follow, boolean withIdentifiers)
1857 */
1858 public Collection<AttributeFacade> getAttributes(boolean follow, boolean withIdentifiers)
1859 {
1860 return this.getSuperSpringEntity().getAttributes(follow, withIdentifiers);
1861 }
1862
1863 /**
1864 * Gets all attributes of the entity, and optionally retieves the super entities attributes as
1865 * well as excludes the entity's identifiers if 'withIdentifiers' is set to false and exclude
1866 * derived attributes if 'withDerived' is set to false.
1867 * @see org.andromda.metafacades.uml.Entity#getAttributes(boolean follow, boolean withIdentifiers, boolean withDerived)
1868 */
1869 public Collection<AttributeFacade> getAttributes(boolean follow, boolean withIdentifiers, boolean withDerived)
1870 {
1871 return this.getSuperSpringEntity().getAttributes(follow, withIdentifiers, withDerived);
1872 }
1873
1874 /**
1875 * All business operations of the entity, these include any operations that aren't queries.
1876 * @see org.andromda.metafacades.uml.Entity#getBusinessOperations()
1877 */
1878 public Collection<OperationFacade> getBusinessOperations()
1879 {
1880 return this.getSuperSpringEntity().getBusinessOperations();
1881 }
1882
1883 /**
1884 * Gets any children association ends (i.e. entity association ends that are participants in an
1885 * association with this entity and this entity has composite aggregation defined for those
1886 * associations).
1887 * @see org.andromda.metafacades.uml.Entity#getChildEnds()
1888 */
1889 public Collection<EntityAssociationEnd> getChildEnds()
1890 {
1891 return this.getSuperSpringEntity().getChildEnds();
1892 }
1893
1894 /**
1895 * The embedded values belonging to this entity.
1896 * @see org.andromda.metafacades.uml.Entity#getEmbeddedValues()
1897 */
1898 public Collection<AttributeFacade> getEmbeddedValues()
1899 {
1900 return this.getSuperSpringEntity().getEmbeddedValues();
1901 }
1902
1903 /**
1904 * All entities referenced by this entity.
1905 * @see org.andromda.metafacades.uml.Entity#getEntityReferences()
1906 */
1907 public Collection<DependencyFacade> getEntityReferences()
1908 {
1909 return this.getSuperSpringEntity().getEntityReferences();
1910 }
1911
1912 /**
1913 * The full name of the type of the identifier. If composite identifier add the PK sufix to the
1914 * class name. If not, retorns the fully qualified name of the identifier.
1915 * @see org.andromda.metafacades.uml.Entity#getFullyQualifiedIdentifierTypeName()
1916 */
1917 public String getFullyQualifiedIdentifierTypeName()
1918 {
1919 return this.getSuperSpringEntity().getFullyQualifiedIdentifierTypeName();
1920 }
1921
1922 /**
1923 * Gets all the associationEnds of this entity marked with the identifiers stereotype.
1924 * @see org.andromda.metafacades.uml.Entity#getIdentifierAssociationEnds()
1925 */
1926 public Collection<AssociationEndFacade> getIdentifierAssociationEnds()
1927 {
1928 return this.getSuperSpringEntity().getIdentifierAssociationEnds();
1929 }
1930
1931 /**
1932 * The getter name of the identifier.
1933 * @see org.andromda.metafacades.uml.Entity#getIdentifierGetterName()
1934 */
1935 public String getIdentifierGetterName()
1936 {
1937 return this.getSuperSpringEntity().getIdentifierGetterName();
1938 }
1939
1940 /**
1941 * The name of the identifier. If composite identifier add the Pk suffix. If not composite
1942 * returns the attribute name of the identifier.
1943 * @see org.andromda.metafacades.uml.Entity#getIdentifierName()
1944 */
1945 public String getIdentifierName()
1946 {
1947 return this.getSuperSpringEntity().getIdentifierName();
1948 }
1949
1950 /**
1951 * The setter name of the identifier.
1952 * @see org.andromda.metafacades.uml.Entity#getIdentifierSetterName()
1953 */
1954 public String getIdentifierSetterName()
1955 {
1956 return this.getSuperSpringEntity().getIdentifierSetterName();
1957 }
1958
1959 /**
1960 * The name of the type of the identifier. If composite identifier add the PK suffix to the
1961 * class name. If not, returns the name of the identifier.
1962 * @see org.andromda.metafacades.uml.Entity#getIdentifierTypeName()
1963 */
1964 public String getIdentifierTypeName()
1965 {
1966 return this.getSuperSpringEntity().getIdentifierTypeName();
1967 }
1968
1969 /**
1970 * All the attributes of the entity which make up its identifier (primary key). Will search any
1971 * super classes as well. If no identifiers exist, a default identifier will be created if the
1972 * allowDefaultIdentifiers property is set to true.
1973 * @see org.andromda.metafacades.uml.Entity#getIdentifiers()
1974 */
1975 public Collection<ModelElementFacade> getIdentifiers()
1976 {
1977 return this.getSuperSpringEntity().getIdentifiers();
1978 }
1979
1980 /**
1981 * Gets all identifiers for an entity. If 'follow' is true, and if no identifiers can be found
1982 * on the entity, a search up the inheritance chain will be performed, and the identifiers from
1983 * the first super class having them will be used. If no identifiers exist, a default
1984 * identifier will be created if the allowDefaultIdentifiers property is set to true.
1985 * Identifiers can be on attributes or associations (composite primary key).
1986 * @see org.andromda.metafacades.uml.Entity#getIdentifiers(boolean follow)
1987 */
1988 public Collection<ModelElementFacade> getIdentifiers(boolean follow)
1989 {
1990 return this.getSuperSpringEntity().getIdentifiers(follow);
1991 }
1992
1993 /**
1994 * The maximum length a SQL name may be.
1995 * @see org.andromda.metafacades.uml.Entity#getMaxSqlNameLength()
1996 */
1997 public short getMaxSqlNameLength()
1998 {
1999 return this.getSuperSpringEntity().getMaxSqlNameLength();
2000 }
2001
2002 /**
2003 * Gets the attributes as a list within an operation call, optionally including the type names
2004 * and the identifier attributes.
2005 * @see org.andromda.metafacades.uml.Entity#getOperationCallFromAttributes(boolean withIdentifiers)
2006 */
2007 public String getOperationCallFromAttributes(boolean withIdentifiers)
2008 {
2009 return this.getSuperSpringEntity().getOperationCallFromAttributes(withIdentifiers);
2010 }
2011
2012 /**
2013 * Gets the attributes as a list within an operation call. If 'withTypeNames' is true, it will
2014 * include the type names, if 'withIdentifiers' is true it will include the identifiers. If
2015 * 'follow' is true it will follow the inheritance hierarchy and get the attributes of the super
2016 * class as well.
2017 * @see org.andromda.metafacades.uml.Entity#getOperationCallFromAttributes(boolean withIdentifiers, boolean follow)
2018 */
2019 public String getOperationCallFromAttributes(boolean withIdentifiers, boolean follow)
2020 {
2021 return this.getSuperSpringEntity().getOperationCallFromAttributes(withIdentifiers, follow);
2022 }
2023
2024 /**
2025 * Returns the parent association end of this entity if its a child entity. The parent is the
2026 * entity that is the participant the association that has composite aggregation defined. Will
2027 * return null if the entity has no parent.
2028 * @see org.andromda.metafacades.uml.Entity#getParentEnd()
2029 */
2030 public EntityAssociationEnd getParentEnd()
2031 {
2032 return this.getSuperSpringEntity().getParentEnd();
2033 }
2034
2035 /**
2036 * Gets all properties of this entity, this includes the attributes and navigable association
2037 * ends of the entity. The 'follow' flag indcates whether or not the inheritance hierarchy
2038 * should be followed when getting all the properties. The 'withIdentifiers' flag indicates
2039 * whether or not identifiers should be included in the collection of properties.
2040 * @see org.andromda.metafacades.uml.Entity#getProperties(boolean follow, boolean withIdentifiers)
2041 */
2042 public Collection<ModelElementFacade> getProperties(boolean follow, boolean withIdentifiers)
2043 {
2044 return this.getSuperSpringEntity().getProperties(follow, withIdentifiers);
2045 }
2046
2047 /**
2048 * Returns all the operations that can perform queries on the entity.
2049 * @see org.andromda.metafacades.uml.Entity#getQueryOperations()
2050 */
2051 public Collection<EntityQueryOperation> getQueryOperations()
2052 {
2053 return this.getSuperSpringEntity().getQueryOperations();
2054 }
2055
2056 /**
2057 * Gets all query operations for an entity. If 'follow' is true, and if no query operations can
2058 * be found on the entity, a search up the inheritance chain will be performed, and the
2059 * identifiers from the first super class having them will be used. If no identifiers exist, a
2060 * default identifier will be created if the allowDefaultIdentifiers property is set to true.
2061 * @see org.andromda.metafacades.uml.Entity#getQueryOperations(boolean follow)
2062 */
2063 public Collection<OperationFacade> getQueryOperations(boolean follow)
2064 {
2065 return this.getSuperSpringEntity().getQueryOperations(follow);
2066 }
2067
2068 /**
2069 * Gets a comma separated list of required attribute names. If 'follow' is true, will travel up
2070 * the inheritance hierarchy to include attributes in parent entities as well. If
2071 * 'withIdentifiers' is true, will include identifiers.
2072 * @see org.andromda.metafacades.uml.Entity#getRequiredAttributeNameList(boolean follow, boolean withIdentifiers)
2073 */
2074 public String getRequiredAttributeNameList(boolean follow, boolean withIdentifiers)
2075 {
2076 return this.getSuperSpringEntity().getRequiredAttributeNameList(follow, withIdentifiers);
2077 }
2078
2079 /**
2080 * Gets a comma separated list of attribute types with are required. If 'follow' is true, will
2081 * travel up the inheritance hierarchy to include attributes in parent entities as well. If
2082 * 'withIdentifiers' is true, will include identifiers.
2083 * @see org.andromda.metafacades.uml.Entity#getRequiredAttributeTypeList(boolean follow, boolean withIdentifiers)
2084 */
2085 public String getRequiredAttributeTypeList(boolean follow, boolean withIdentifiers)
2086 {
2087 return this.getSuperSpringEntity().getRequiredAttributeTypeList(follow, withIdentifiers);
2088 }
2089
2090 /**
2091 * Returns all attributes that are specified as 'required' in the model. If 'follow' is true,
2092 * then required attributes in super classes will also be returned, if false, just the ones
2093 * directly on the entity will be returned. If 'withIdentifiers' is true, the identifiers will
2094 * be include, if false, no identifiers will be included.
2095 * @see org.andromda.metafacades.uml.Entity#getRequiredAttributes(boolean follow, boolean withIdentifiers)
2096 */
2097 public Collection<AttributeFacade> getRequiredAttributes(boolean follow, boolean withIdentifiers)
2098 {
2099 return this.getSuperSpringEntity().getRequiredAttributes(follow, withIdentifiers);
2100 }
2101
2102 /**
2103 * Gets all required properties for this entity. These consist of any required attributes as
2104 * well as navigable associations that are marked as 'required'. If 'follow' is true, then the
2105 * inheritance hierchy will be followed and all required properties from super classes will be
2106 * included as well.
2107 * If 'withIdentifiers' is true, the identifiers will be include, if false, no identifiers will
2108 * be included.
2109 * @see org.andromda.metafacades.uml.Entity#getRequiredProperties(boolean follow, boolean withIdentifiers)
2110 */
2111 public Collection<ModelElementFacade> getRequiredProperties(boolean follow, boolean withIdentifiers)
2112 {
2113 return this.getSuperSpringEntity().getRequiredProperties(follow, withIdentifiers);
2114 }
2115
2116 /**
2117 * Creates a comma separated list of the required property names.
2118 * @see org.andromda.metafacades.uml.Entity#getRequiredPropertyNameList(boolean follow, boolean withIdentifiers)
2119 */
2120 public String getRequiredPropertyNameList(boolean follow, boolean withIdentifiers)
2121 {
2122 return this.getSuperSpringEntity().getRequiredPropertyNameList(follow, withIdentifiers);
2123 }
2124
2125 /**
2126 * A comma separated list of the required property types.
2127 * @see org.andromda.metafacades.uml.Entity#getRequiredPropertyTypeList(boolean follow, boolean withIdentifiers)
2128 */
2129 public String getRequiredPropertyTypeList(boolean follow, boolean withIdentifiers)
2130 {
2131 return this.getSuperSpringEntity().getRequiredPropertyTypeList(follow, withIdentifiers);
2132 }
2133
2134 /**
2135 * The name of the schema that contains the database table
2136 * @see org.andromda.metafacades.uml.Entity#getSchema()
2137 */
2138 public String getSchema()
2139 {
2140 return this.getSuperSpringEntity().getSchema();
2141 }
2142
2143 /**
2144 * The name of the database table to which this entity is persisted.
2145 * @see org.andromda.metafacades.uml.Entity#getTableName()
2146 */
2147 public String getTableName()
2148 {
2149 return this.getSuperSpringEntity().getTableName();
2150 }
2151
2152 /**
2153 * Returns true/false depending on whether or not this entity represetns a child in an
2154 * association (this occurs when this entity is on the opposite end of an assocation end defined
2155 * as composite).
2156 * @see org.andromda.metafacades.uml.Entity#isChild()
2157 */
2158 public boolean isChild()
2159 {
2160 return this.getSuperSpringEntity().isChild();
2161 }
2162
2163 /**
2164 * True if this entity identifier is a composite (consists of multiple key columns, typically
2165 * abstracted into an external composite identifier class)
2166 * @see org.andromda.metafacades.uml.Entity#isCompositeIdentifier()
2167 */
2168 public boolean isCompositeIdentifier()
2169 {
2170 return this.getSuperSpringEntity().isCompositeIdentifier();
2171 }
2172
2173 /**
2174 * True if the entity has its identifiers dynamically added, false otherwise.
2175 * @see org.andromda.metafacades.uml.Entity#isDynamicIdentifiersPresent()
2176 */
2177 public boolean isDynamicIdentifiersPresent()
2178 {
2179 return this.getSuperSpringEntity().isDynamicIdentifiersPresent();
2180 }
2181
2182 /**
2183 * True if the entity has any identifiers defined, false otherwise.
2184 * @see org.andromda.metafacades.uml.Entity#isIdentifiersPresent()
2185 */
2186 public boolean isIdentifiersPresent()
2187 {
2188 return this.getSuperSpringEntity().isIdentifiersPresent();
2189 }
2190
2191 /**
2192 * Indiciates if this entity is using an assigned identifier or not.
2193 * @see org.andromda.metafacades.uml.Entity#isUsingAssignedIdentifier()
2194 */
2195 public boolean isUsingAssignedIdentifier()
2196 {
2197 return this.getSuperSpringEntity().isUsingAssignedIdentifier();
2198 }
2199
2200 /**
2201 * Indicates whether or not this entity is using a foreign identifier as its identifiers. That
2202 * is: the foreignIdentifier flag was set on an incoming association end and the entity is
2203 * therefore using the related foreign parent entity's identifier.
2204 * @see org.andromda.metafacades.uml.Entity#isUsingForeignIdentifier()
2205 */
2206 public boolean isUsingForeignIdentifier()
2207 {
2208 return this.getSuperSpringEntity().isUsingForeignIdentifier();
2209 }
2210
2211 /**
2212 * Finds the tagged value optional searching the entire inheritance hierarchy if 'follow' is set
2213 * to true.
2214 * @see GeneralizableElementFacade#findTaggedValue(String tagName, boolean follow)
2215 */
2216 public Object findTaggedValue(String tagName, boolean follow)
2217 {
2218 return this.getSuperSpringEntity().findTaggedValue(tagName, follow);
2219 }
2220
2221 /**
2222 * All generalizations for this generalizable element, goes up the inheritance tree.
2223 * @see GeneralizableElementFacade#getAllGeneralizations()
2224 */
2225 public Collection<GeneralizableElementFacade> getAllGeneralizations()
2226 {
2227 return this.getSuperSpringEntity().getAllGeneralizations();
2228 }
2229
2230 /**
2231 * All specializations (travels down the inheritance hierarchy).
2232 * @see GeneralizableElementFacade#getAllSpecializations()
2233 */
2234 public Collection<GeneralizableElementFacade> getAllSpecializations()
2235 {
2236 return this.getSuperSpringEntity().getAllSpecializations();
2237 }
2238
2239 /**
2240 * Gets the direct generalization for this generalizable element.
2241 * @see GeneralizableElementFacade#getGeneralization()
2242 */
2243 public GeneralizableElementFacade getGeneralization()
2244 {
2245 return this.getSuperSpringEntity().getGeneralization();
2246 }
2247
2248 /**
2249 * Gets the actual links that this generalization element is part of (it plays either the
2250 * specialization or generalization).
2251 * @see GeneralizableElementFacade#getGeneralizationLinks()
2252 */
2253 public Collection<GeneralizationFacade> getGeneralizationLinks()
2254 {
2255 return this.getSuperSpringEntity().getGeneralizationLinks();
2256 }
2257
2258 /**
2259 * A comma separated list of the fully qualified names of all generalizations.
2260 * @see GeneralizableElementFacade#getGeneralizationList()
2261 */
2262 public String getGeneralizationList()
2263 {
2264 return this.getSuperSpringEntity().getGeneralizationList();
2265 }
2266
2267 /**
2268 * The element found when you recursively follow the generalization path up to the root. If an
2269 * element has no generalization itself will be considered the root.
2270 * @see GeneralizableElementFacade#getGeneralizationRoot()
2271 */
2272 public GeneralizableElementFacade getGeneralizationRoot()
2273 {
2274 return this.getSuperSpringEntity().getGeneralizationRoot();
2275 }
2276
2277 /**
2278 * Return all generalizations (ancestors) from this generalizable element.
2279 * @see GeneralizableElementFacade#getGeneralizations()
2280 */
2281 public Collection<GeneralizableElementFacade> getGeneralizations()
2282 {
2283 return this.getSuperSpringEntity().getGeneralizations();
2284 }
2285
2286 /**
2287 * Gets the direct specializations (i.e. sub elements) for this generalizatble element.
2288 * @see GeneralizableElementFacade#getSpecializations()
2289 */
2290 public Collection<GeneralizableElementFacade> getSpecializations()
2291 {
2292 return this.getSuperSpringEntity().getSpecializations();
2293 }
2294
2295 /**
2296 * Copies all tagged values from the given ModelElementFacade to this model element facade.
2297 * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element)
2298 */
2299 public void copyTaggedValues(ModelElementFacade element)
2300 {
2301 this.getSuperSpringEntity().copyTaggedValues(element);
2302 }
2303
2304 /**
2305 * Finds the tagged value with the specified 'tagName'. In case there are more values the first
2306 * one found will be returned.
2307 * @see ModelElementFacade#findTaggedValue(String tagName)
2308 */
2309 public Object findTaggedValue(String tagName)
2310 {
2311 return this.getSuperSpringEntity().findTaggedValue(tagName);
2312 }
2313
2314 /**
2315 * Returns all the values for the tagged value with the specified name. The returned collection
2316 * will contains only String instances, or will be empty. Never null.
2317 * @see ModelElementFacade#findTaggedValues(String tagName)
2318 */
2319 public Collection<Object> findTaggedValues(String tagName)
2320 {
2321 return this.getSuperSpringEntity().findTaggedValues(tagName);
2322 }
2323
2324 /**
2325 * Returns the fully qualified name of the model element. The fully qualified name includes
2326 * complete package qualified name of the underlying model element. The templates parameter will
2327 * be replaced by the correct one given the binding relation of the parameter to this element.
2328 * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement)
2329 */
2330 public String getBindedFullyQualifiedName(ModelElementFacade bindedElement)
2331 {
2332 return this.getSuperSpringEntity().getBindedFullyQualifiedName(bindedElement);
2333 }
2334
2335 /**
2336 * Gets all constraints belonging to the model element.
2337 * @see ModelElementFacade#getConstraints()
2338 */
2339 public Collection<ConstraintFacade> getConstraints()
2340 {
2341 return this.getSuperSpringEntity().getConstraints();
2342 }
2343
2344 /**
2345 * Returns the constraints of the argument kind that have been placed onto this model. Typical
2346 * kinds are "inv", "pre" and "post". Other kinds are possible.
2347 * @see ModelElementFacade#getConstraints(String kind)
2348 */
2349 public Collection<ConstraintFacade> getConstraints(String kind)
2350 {
2351 return this.getSuperSpringEntity().getConstraints(kind);
2352 }
2353
2354 /**
2355 * Gets the documentation for the model element, The indent argument is prefixed to each line.
2356 * By default this method wraps lines after 64 characters.
2357 * This method is equivalent to <code>getDocumentation(indent, 64)</code>.
2358 * @see ModelElementFacade#getDocumentation(String indent)
2359 */
2360 public String getDocumentation(String indent)
2361 {
2362 return this.getSuperSpringEntity().getDocumentation(indent);
2363 }
2364
2365 /**
2366 * This method returns the documentation for this model element, with the lines wrapped after
2367 * the specified number of characters, values of less than 1 will indicate no line wrapping is
2368 * required. By default paragraphs are returned as HTML.
2369 * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>.
2370 * @see ModelElementFacade#getDocumentation(String indent, int lineLength)
2371 */
2372 public String getDocumentation(String indent, int lineLength)
2373 {
2374 return this.getSuperSpringEntity().getDocumentation(indent, lineLength);
2375 }
2376
2377 /**
2378 * This method returns the documentation for this model element, with the lines wrapped after
2379 * the specified number of characters, values of less than 1 will indicate no line wrapping is
2380 * required. HTML style determines if HTML Escaping is applied.
2381 * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle)
2382 */
2383 public String getDocumentation(String indent, int lineLength, boolean htmlStyle)
2384 {
2385 return this.getSuperSpringEntity().getDocumentation(indent, lineLength, htmlStyle);
2386 }
2387
2388 /**
2389 * The fully qualified name of this model element.
2390 * @see ModelElementFacade#getFullyQualifiedName()
2391 */
2392 public String getFullyQualifiedName()
2393 {
2394 return this.getSuperSpringEntity().getFullyQualifiedName();
2395 }
2396
2397 /**
2398 * Returns the fully qualified name of the model element. The fully qualified name includes
2399 * complete package qualified name of the underlying model element. If modelName is true, then
2400 * the original name of the model element (the name contained within the model) will be the name
2401 * returned, otherwise a name from a language mapping will be returned.
2402 * @see ModelElementFacade#getFullyQualifiedName(boolean modelName)
2403 */
2404 public String getFullyQualifiedName(boolean modelName)
2405 {
2406 return this.getSuperSpringEntity().getFullyQualifiedName(modelName);
2407 }
2408
2409 /**
2410 * Returns the fully qualified name as a path, the returned value always starts with out a slash
2411 * '/'.
2412 * @see ModelElementFacade#getFullyQualifiedNamePath()
2413 */
2414 public String getFullyQualifiedNamePath()
2415 {
2416 return this.getSuperSpringEntity().getFullyQualifiedNamePath();
2417 }
2418
2419 /**
2420 * Gets the unique identifier of the underlying model element.
2421 * @see ModelElementFacade#getId()
2422 */
2423 public String getId()
2424 {
2425 return this.getSuperSpringEntity().getId();
2426 }
2427
2428 /**
2429 * UML2: Retrieves the keywords for this element. Used to modify implementation properties which
2430 * are not represented by other properties, i.e. native, transient, volatile, synchronized,
2431 * (added annotations) override, deprecated. Can also be used to suppress compiler warnings:
2432 * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require
2433 * JDK5 compiler level.
2434 * @see ModelElementFacade#getKeywords()
2435 */
2436 public Collection<String> getKeywords()
2437 {
2438 return this.getSuperSpringEntity().getKeywords();
2439 }
2440
2441 /**
2442 * UML2: Retrieves a localized label for this named element.
2443 * @see ModelElementFacade#getLabel()
2444 */
2445 public String getLabel()
2446 {
2447 return this.getSuperSpringEntity().getLabel();
2448 }
2449
2450 /**
2451 * The language mappings that have been set for this model element.
2452 * @see ModelElementFacade#getLanguageMappings()
2453 */
2454 public TypeMappings getLanguageMappings()
2455 {
2456 return this.getSuperSpringEntity().getLanguageMappings();
2457 }
2458
2459 /**
2460 * Return the model containing this model element (multiple models may be loaded and processed
2461 * at the same time).
2462 * @see ModelElementFacade#getModel()
2463 */
2464 public ModelFacade getModel()
2465 {
2466 return this.getSuperSpringEntity().getModel();
2467 }
2468
2469 /**
2470 * The name of the model element.
2471 * @see ModelElementFacade#getName()
2472 */
2473 public String getName()
2474 {
2475 return this.getSuperSpringEntity().getName();
2476 }
2477
2478 /**
2479 * Gets the package to which this model element belongs.
2480 * @see ModelElementFacade#getPackage()
2481 */
2482 public ModelElementFacade getPackage()
2483 {
2484 return this.getSuperSpringEntity().getPackage();
2485 }
2486
2487 /**
2488 * The name of this model element's package.
2489 * @see ModelElementFacade#getPackageName()
2490 */
2491 public String getPackageName()
2492 {
2493 return this.getSuperSpringEntity().getPackageName();
2494 }
2495
2496 /**
2497 * Gets the package name (optionally providing the ability to retrieve the model name and not
2498 * the mapped name).
2499 * @see ModelElementFacade#getPackageName(boolean modelName)
2500 */
2501 public String getPackageName(boolean modelName)
2502 {
2503 return this.getSuperSpringEntity().getPackageName(modelName);
2504 }
2505
2506 /**
2507 * Returns the package as a path, the returned value always starts with out a slash '/'.
2508 * @see ModelElementFacade#getPackagePath()
2509 */
2510 public String getPackagePath()
2511 {
2512 return this.getSuperSpringEntity().getPackagePath();
2513 }
2514
2515 /**
2516 * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the
2517 * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from
2518 * the names of the containing namespaces starting at the root of the hierarchy and ending with
2519 * the name of the NamedElement itself.
2520 * @see ModelElementFacade#getQualifiedName()
2521 */
2522 public String getQualifiedName()
2523 {
2524 return this.getSuperSpringEntity().getQualifiedName();
2525 }
2526
2527 /**
2528 * Gets the root package for the model element.
2529 * @see ModelElementFacade#getRootPackage()
2530 */
2531 public PackageFacade getRootPackage()
2532 {
2533 return this.getSuperSpringEntity().getRootPackage();
2534 }
2535
2536 /**
2537 * Gets the dependencies for which this model element is the source.
2538 * @see ModelElementFacade#getSourceDependencies()
2539 */
2540 public Collection<DependencyFacade> getSourceDependencies()
2541 {
2542 return this.getSuperSpringEntity().getSourceDependencies();
2543 }
2544
2545 /**
2546 * If this model element is the context of an activity graph, this represents that activity
2547 * graph.
2548 * @see ModelElementFacade#getStateMachineContext()
2549 */
2550 public StateMachineFacade getStateMachineContext()
2551 {
2552 return this.getSuperSpringEntity().getStateMachineContext();
2553 }
2554
2555 /**
2556 * The collection of ALL stereotype names for this model element.
2557 * @see ModelElementFacade#getStereotypeNames()
2558 */
2559 public Collection<String> getStereotypeNames()
2560 {
2561 return this.getSuperSpringEntity().getStereotypeNames();
2562 }
2563
2564 /**
2565 * Gets all stereotypes for this model element.
2566 * @see ModelElementFacade#getStereotypes()
2567 */
2568 public Collection<StereotypeFacade> getStereotypes()
2569 {
2570 return this.getSuperSpringEntity().getStereotypes();
2571 }
2572
2573 /**
2574 * Return the TaggedValues associated with this model element, under all stereotypes.
2575 * @see ModelElementFacade#getTaggedValues()
2576 */
2577 public Collection<TaggedValueFacade> getTaggedValues()
2578 {
2579 return this.getSuperSpringEntity().getTaggedValues();
2580 }
2581
2582 /**
2583 * Gets the dependencies for which this model element is the target.
2584 * @see ModelElementFacade#getTargetDependencies()
2585 */
2586 public Collection<DependencyFacade> getTargetDependencies()
2587 {
2588 return this.getSuperSpringEntity().getTargetDependencies();
2589 }
2590
2591 /**
2592 * Get the template parameter for this model element having the parameterName
2593 * @see ModelElementFacade#getTemplateParameter(String parameterName)
2594 */
2595 public Object getTemplateParameter(String parameterName)
2596 {
2597 return this.getSuperSpringEntity().getTemplateParameter(parameterName);
2598 }
2599
2600 /**
2601 * Get the template parameters for this model element
2602 * @see ModelElementFacade#getTemplateParameters()
2603 */
2604 public Collection<TemplateParameterFacade> getTemplateParameters()
2605 {
2606 return this.getSuperSpringEntity().getTemplateParameters();
2607 }
2608
2609 /**
2610 * The visibility (i.e. public, private, protected or package) of the model element, will
2611 * attempt a lookup for these values in the language mappings (if any).
2612 * @see ModelElementFacade#getVisibility()
2613 */
2614 public String getVisibility()
2615 {
2616 return this.getSuperSpringEntity().getVisibility();
2617 }
2618
2619 /**
2620 * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance
2621 * is taken into account when searching for the stereotype), false otherwise.
2622 * @see ModelElementFacade#hasExactStereotype(String stereotypeName)
2623 */
2624 public boolean hasExactStereotype(String stereotypeName)
2625 {
2626 return this.getSuperSpringEntity().hasExactStereotype(stereotypeName);
2627 }
2628
2629 /**
2630 * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma,
2631 * pipe, semicolon, or << >>
2632 * @see ModelElementFacade#hasKeyword(String keywordName)
2633 */
2634 public boolean hasKeyword(String keywordName)
2635 {
2636 return this.getSuperSpringEntity().hasKeyword(keywordName);
2637 }
2638
2639 /**
2640 * Returns true if the model element has the specified stereotype. If the stereotype itself
2641 * does not match, then a search will be made up the stereotype inheritance hierarchy, and if
2642 * one of the stereotype's ancestors has a matching name this method will return true, false
2643 * otherwise.
2644 * For example, if we have a certain stereotype called <<exception>> and a model element has a
2645 * stereotype called <<applicationException>> which extends <<exception>>, when calling this
2646 * method with 'stereotypeName' defined as 'exception' the method would return true since
2647 * <<applicationException>> inherits from <<exception>>. If you want to check if the model
2648 * element has the exact stereotype, then use the method 'hasExactStereotype' instead.
2649 * @see ModelElementFacade#hasStereotype(String stereotypeName)
2650 */
2651 public boolean hasStereotype(String stereotypeName)
2652 {
2653 return this.getSuperSpringEntity().hasStereotype(stereotypeName);
2654 }
2655
2656 /**
2657 * True if there are target dependencies from this element that are instances of BindingFacade.
2658 * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies.
2659 * @see ModelElementFacade#isBindingDependenciesPresent()
2660 */
2661 public boolean isBindingDependenciesPresent()
2662 {
2663 return this.getSuperSpringEntity().isBindingDependenciesPresent();
2664 }
2665
2666 /**
2667 * Indicates if any constraints are present on this model element.
2668 * @see ModelElementFacade#isConstraintsPresent()
2669 */
2670 public boolean isConstraintsPresent()
2671 {
2672 return this.getSuperSpringEntity().isConstraintsPresent();
2673 }
2674
2675 /**
2676 * Indicates if any documentation is present on this model element.
2677 * @see ModelElementFacade#isDocumentationPresent()
2678 */
2679 public boolean isDocumentationPresent()
2680 {
2681 return this.getSuperSpringEntity().isDocumentationPresent();
2682 }
2683
2684 /**
2685 * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript.
2686 * @see ModelElementFacade#isReservedWord()
2687 */
2688 public boolean isReservedWord()
2689 {
2690 return this.getSuperSpringEntity().isReservedWord();
2691 }
2692
2693 /**
2694 * True is there are template parameters on this model element. For UML2, applies to Class,
2695 * Operation, Property, and Parameter.
2696 * @see ModelElementFacade#isTemplateParametersPresent()
2697 */
2698 public boolean isTemplateParametersPresent()
2699 {
2700 return this.getSuperSpringEntity().isTemplateParametersPresent();
2701 }
2702
2703 /**
2704 * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++,
2705 * JavaScript. Contains no spaces, special characters etc. Constraint always applied on
2706 * Enumerations and Interfaces, optionally applies on other model elements.
2707 * @see ModelElementFacade#isValidIdentifierName()
2708 */
2709 public boolean isValidIdentifierName()
2710 {
2711 return this.getSuperSpringEntity().isValidIdentifierName();
2712 }
2713
2714 /**
2715 * Searches for the constraint with the specified 'name' on this model element, and if found
2716 * translates it using the specified 'translation' from a translation library discovered by the
2717 * framework.
2718 * @see ModelElementFacade#translateConstraint(String name, String translation)
2719 */
2720 public String translateConstraint(String name, String translation)
2721 {
2722 return this.getSuperSpringEntity().translateConstraint(name, translation);
2723 }
2724
2725 /**
2726 * Translates all constraints belonging to this model element with the given 'translation'.
2727 * @see ModelElementFacade#translateConstraints(String translation)
2728 */
2729 public String[] translateConstraints(String translation)
2730 {
2731 return this.getSuperSpringEntity().translateConstraints(translation);
2732 }
2733
2734 /**
2735 * Translates the constraints of the specified 'kind' belonging to this model element.
2736 * @see ModelElementFacade#translateConstraints(String kind, String translation)
2737 */
2738 public String[] translateConstraints(String kind, String translation)
2739 {
2740 return this.getSuperSpringEntity().translateConstraints(kind, translation);
2741 }
2742
2743 // ----------- delegates to ManageableEntity ------------
2744 /**
2745 * All entities to which can be browsed from this entity. Currently this property will simple
2746 * hold all entities, so the value is the same for any arbitrary entity. Hiding entities can be
2747 * done in the presentation tier, for example depending on runtime security information.
2748 * @see ManageableEntity#getAllManageables()
2749 */
2750 public List<ManageableEntity> getAllManageables()
2751 {
2752 return this.getSuperManageableEntity().getAllManageables();
2753 }
2754
2755 /**
2756 * The attribute used as a key link to display values for this entity.
2757 * @see ManageableEntity#getDisplayAttribute()
2758 */
2759 public ManageableEntityAttribute getDisplayAttribute()
2760 {
2761 return this.getSuperManageableEntity().getDisplayAttribute();
2762 }
2763
2764 /**
2765 * The fully qualified service name of the entity.
2766 * @see ManageableEntity#getFullyQualifiedManageableServiceName()
2767 */
2768 public String getFullyQualifiedManageableServiceName()
2769 {
2770 return this.getSuperManageableEntity().getFullyQualifiedManageableServiceName();
2771 }
2772
2773 /**
2774 * The associations to other entities from this entity.
2775 * @see ManageableEntity#getManageableAssociationEnds()
2776 */
2777 public List<ManageableEntityAssociationEnd> getManageableAssociationEnds()
2778 {
2779 return this.getSuperManageableEntity().getManageableAssociationEnds();
2780 }
2781
2782 /**
2783 * Lists the attributes that can be managed for this entity. This feature is particularly
2784 * important when resolving inherited attributes and ids.
2785 * @see ManageableEntity#getManageableAttributes()
2786 */
2787 public List<ManageableEntityAttribute> getManageableAttributes()
2788 {
2789 return this.getSuperManageableEntity().getManageableAttributes();
2790 }
2791
2792 /**
2793 * The identifier used when managing this entity.
2794 * @see ManageableEntity#getManageableIdentifier()
2795 */
2796 public ManageableEntityAttribute getManageableIdentifier()
2797 {
2798 return this.getSuperManageableEntity().getManageableIdentifier();
2799 }
2800
2801 /**
2802 * ManageableAttributes and ManageableAssociationEnds
2803 * @see ManageableEntity#getManageableMembers()
2804 */
2805 public List<ModelElementFacade> getManageableMembers()
2806 {
2807 return this.getSuperManageableEntity().getManageableMembers();
2808 }
2809
2810 /**
2811 * The entity package name.
2812 * @see ManageableEntity#getManageablePackageName()
2813 */
2814 public String getManageablePackageName()
2815 {
2816 return this.getSuperManageableEntity().getManageablePackageName();
2817 }
2818
2819 /**
2820 * The Package path of the Entity
2821 * @see ManageableEntity#getManageablePackagePath()
2822 */
2823 public String getManageablePackagePath()
2824 {
2825 return this.getSuperManageableEntity().getManageablePackagePath();
2826 }
2827
2828 /**
2829 * The entity accessor (getter) call.
2830 * @see ManageableEntity#getManageableServiceAccessorCall()
2831 */
2832 public String getManageableServiceAccessorCall()
2833 {
2834 return this.getSuperManageableEntity().getManageableServiceAccessorCall();
2835 }
2836
2837 /**
2838 * The service full path of the entity.
2839 * @see ManageableEntity#getManageableServiceFullPath()
2840 */
2841 public String getManageableServiceFullPath()
2842 {
2843 return this.getSuperManageableEntity().getManageableServiceFullPath();
2844 }
2845
2846 /**
2847 * The service name of the entity.
2848 * @see ManageableEntity#getManageableServiceName()
2849 */
2850 public String getManageableServiceName()
2851 {
2852 return this.getSuperManageableEntity().getManageableServiceName();
2853 }
2854
2855 /**
2856 * The maximum number of rows to load from the database.
2857 * @see ManageableEntity#getMaximumListSize()
2858 */
2859 public int getMaximumListSize()
2860 {
2861 return this.getSuperManageableEntity().getMaximumListSize();
2862 }
2863
2864 /**
2865 * The maximum number of rows to load from the database.
2866 * @see ManageableEntity#getPageSize()
2867 */
2868 public int getPageSize()
2869 {
2870 return this.getSuperManageableEntity().getPageSize();
2871 }
2872
2873 /**
2874 * Other Manageable Entities which reference this entity.
2875 * @see ManageableEntity#getReferencingManageables()
2876 */
2877 public List<ManageableEntity> getReferencingManageables()
2878 {
2879 return this.getSuperManageableEntity().getReferencingManageables();
2880 }
2881
2882 /**
2883 * The Actors (Roles) which can manage the Entity.
2884 * @see ManageableEntity#getUsers()
2885 */
2886 public List<ActorFacade> getUsers()
2887 {
2888 return this.getSuperManageableEntity().getUsers();
2889 }
2890
2891 /**
2892 * Create a create operation on the entity manager?
2893 * @see ManageableEntity#isCreate()
2894 */
2895 public boolean isCreate()
2896 {
2897 return this.getSuperManageableEntity().isCreate();
2898 }
2899
2900 /**
2901 * Create a delete operation on the entity manager?
2902 * @see ManageableEntity#isDelete()
2903 */
2904 public boolean isDelete()
2905 {
2906 return this.getSuperManageableEntity().isDelete();
2907 }
2908
2909 /**
2910 * True: Entity is manageable.
2911 * @see ManageableEntity#isManageable()
2912 */
2913 public boolean isManageable()
2914 {
2915 return this.getSuperManageableEntity().isManageable();
2916 }
2917
2918 /**
2919 * Create a read operation on the entity manager?
2920 * @see ManageableEntity#isRead()
2921 */
2922 public boolean isRead()
2923 {
2924 return this.getSuperManageableEntity().isRead();
2925 }
2926
2927 /**
2928 * The maximum number of rows to load from the database.
2929 * @see ManageableEntity#isResolveable()
2930 */
2931 public boolean isResolveable()
2932 {
2933 return this.getSuperManageableEntity().isResolveable();
2934 }
2935
2936 /**
2937 * Create an update operation on the entity manager?
2938 * @see ManageableEntity#isUpdate()
2939 */
2940 public boolean isUpdate()
2941 {
2942 return this.getSuperManageableEntity().isUpdate();
2943 }
2944
2945 /**
2946 * Returns a string with the attributes without wrapper types.
2947 * @see ManageableEntity#listManageableMembers(boolean withTypes)
2948 */
2949 public String listManageableMembers(boolean withTypes)
2950 {
2951 return this.getSuperManageableEntity().listManageableMembers(withTypes);
2952 }
2953
2954 /**
2955 * Returns a string with the attributes and wrapper types.
2956 * @see ManageableEntity#listManageableMembersWithWrapperTypes()
2957 */
2958 public String listManageableMembersWithWrapperTypes()
2959 {
2960 return this.getSuperManageableEntity().listManageableMembersWithWrapperTypes();
2961 }
2962
2963 /**
2964 * @see org.andromda.core.metafacade.MetafacadeBase#initialize()
2965 */
2966 @Override
2967 public void initialize()
2968 {
2969 this.getSuperSpringEntity().initialize();
2970 this.getSuperManageableEntity().initialize();
2971 }
2972
2973 /**
2974 * @return Object getSuperSpringEntity().getValidationOwner()
2975 * @see org.andromda.core.metafacade.MetafacadeBase#getValidationOwner()
2976 */
2977 @Override
2978 public Object getValidationOwner()
2979 {
2980 Object owner = this.getSuperSpringEntity().getValidationOwner();
2981 if (owner == null)
2982 {
2983 owner = this.getSuperManageableEntity().getValidationOwner();
2984 }
2985 return owner;
2986 }
2987
2988 /**
2989 * @return String getSuperSpringEntity().getValidationName()
2990 * @see org.andromda.core.metafacade.MetafacadeBase#getValidationName()
2991 */
2992 @Override
2993 public String getValidationName()
2994 {
2995 String name = this.getSuperSpringEntity().getValidationName();
2996 if (name == null)
2997 {
2998 name = this.getSuperManageableEntity().getValidationName();
2999 }
3000 return name;
3001 }
3002
3003 /**
3004 * @param validationMessages Collection<ModelValidationMessage>
3005 * @see org.andromda.core.metafacade.MetafacadeBase#validateInvariants(Collection validationMessages)
3006 */
3007 @Override
3008 public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
3009 {
3010 this.getSuperSpringEntity().validateInvariants(validationMessages);
3011 this.getSuperManageableEntity().validateInvariants(validationMessages);
3012 }
3013
3014 /**
3015 * The property that stores the name of the metafacade.
3016 */
3017 private static final String NAME_PROPERTY = "name";
3018 private static final String FQNAME_PROPERTY = "fullyQualifiedName";
3019
3020 /**
3021 * @see Object#toString()
3022 */
3023 @Override
3024 public String toString()
3025 {
3026 final StringBuilder toString = new StringBuilder(this.getClass().getName());
3027 toString.append("[");
3028 try
3029 {
3030 toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY));
3031 }
3032 catch (final Throwable tryAgain)
3033 {
3034 try
3035 {
3036 toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY));
3037 }
3038 catch (final Throwable ignore)
3039 {
3040 // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property
3041 }
3042 }
3043 toString.append("]");
3044 return toString.toString();
3045 }
3046 }