1 // license-header java merge-point
2 //
3 // Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
4 //
5 package org.andromda.cartridges.bpm4struts.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.ConstraintFacade;
14 import org.andromda.metafacades.uml.DependencyFacade;
15 import org.andromda.metafacades.uml.FrontEndAction;
16 import org.andromda.metafacades.uml.FrontEndControllerOperation;
17 import org.andromda.metafacades.uml.FrontEndEvent;
18 import org.andromda.metafacades.uml.ModelElementFacade;
19 import org.andromda.metafacades.uml.ModelFacade;
20 import org.andromda.metafacades.uml.PackageFacade;
21 import org.andromda.metafacades.uml.ParameterFacade;
22 import org.andromda.metafacades.uml.StateFacade;
23 import org.andromda.metafacades.uml.StateMachineFacade;
24 import org.andromda.metafacades.uml.StereotypeFacade;
25 import org.andromda.metafacades.uml.TaggedValueFacade;
26 import org.andromda.metafacades.uml.TemplateParameterFacade;
27 import org.andromda.metafacades.uml.TransitionFacade;
28 import org.andromda.metafacades.uml.TypeMappings;
29 import org.andromda.translation.ocl.validation.OCLCollections;
30 import org.andromda.translation.ocl.validation.OCLIntrospector;
31 import org.andromda.translation.ocl.validation.OCLResultEnsurer;
32 import org.apache.log4j.Logger;
33
34 /**
35 * A Struts trigger is represented by clicking a hyperlink or posting an action form.
36 * MetafacadeLogic for StrutsTrigger
37 *
38 * @see StrutsTrigger
39 */
40 public abstract class StrutsTriggerLogic
41 extends MetafacadeBase
42 implements StrutsTrigger
43 {
44 /**
45 * The underlying UML object
46 * @see Object
47 */
48 protected Object metaObject;
49
50 /** Create Metafacade implementation instance using the MetafacadeFactory from the context
51 * @param metaObjectIn
52 * @param context
53 */
54 protected StrutsTriggerLogic(Object metaObjectIn, String context)
55 {
56 super(metaObjectIn, getContext(context));
57 this.superFrontEndEvent =
58 (FrontEndEvent)
59 MetafacadeFactory.getInstance().createFacadeImpl(
60 "org.andromda.metafacades.uml.FrontEndEvent",
61 metaObjectIn,
62 getContext(context));
63 this.metaObject = metaObjectIn;
64 }
65
66 /**
67 * The logger instance.
68 */
69 private static final Logger logger = Logger.getLogger(StrutsTriggerLogic.class);
70
71 /**
72 * Gets the context for this metafacade logic instance.
73 * @param context String. Set to StrutsTrigger if null
74 * @return context String
75 */
76 private static String getContext(String context)
77 {
78 if (context == null)
79 {
80 context = "org.andromda.cartridges.bpm4struts.metafacades.StrutsTrigger";
81 }
82 return context;
83 }
84
85 private FrontEndEvent superFrontEndEvent;
86 private boolean superFrontEndEventInitialized = false;
87
88 /**
89 * Gets the FrontEndEvent parent instance.
90 * @return this.superFrontEndEvent FrontEndEvent
91 */
92 private FrontEndEvent getSuperFrontEndEvent()
93 {
94 if (!this.superFrontEndEventInitialized)
95 {
96 ((MetafacadeBase)this.superFrontEndEvent).setMetafacadeContext(this.getMetafacadeContext());
97 this.superFrontEndEventInitialized = true;
98 }
99 return this.superFrontEndEvent;
100 }
101
102 /** Reset context only for non-root metafacades
103 * @param context
104 * @see MetafacadeBase#resetMetafacadeContext(String context)
105 */
106 @Override
107 public void resetMetafacadeContext(String context)
108 {
109 if (!this.contextRoot) // reset context only for non-root metafacades
110 {
111 context = getContext(context); // to have same value as in original constructor call
112 setMetafacadeContext (context);
113 if (this.superFrontEndEventInitialized)
114 {
115 ((MetafacadeBase)this.superFrontEndEvent).resetMetafacadeContext(context);
116 }
117 }
118 }
119
120 /**
121 * @return boolean true always
122 * @see StrutsTrigger
123 */
124 public boolean isStrutsTriggerMetaType()
125 {
126 return true;
127 }
128
129 // --------------- attributes ---------------------
130
131 /**
132 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsTrigger#getNotAllowedTitleKey()
133 * @return String
134 */
135 protected abstract String handleGetNotAllowedTitleKey();
136
137 private String __notAllowedTitleKey1a;
138 private boolean __notAllowedTitleKey1aSet = false;
139
140 /**
141 * The message key to use as a tooltip when the user is not allowed to use this trigger.
142 * @return (String)handleGetNotAllowedTitleKey()
143 */
144 public final String getNotAllowedTitleKey()
145 {
146 String notAllowedTitleKey1a = this.__notAllowedTitleKey1a;
147 if (!this.__notAllowedTitleKey1aSet)
148 {
149 // notAllowedTitleKey has no pre constraints
150 notAllowedTitleKey1a = handleGetNotAllowedTitleKey();
151 // notAllowedTitleKey has no post constraints
152 this.__notAllowedTitleKey1a = notAllowedTitleKey1a;
153 if (isMetafacadePropertyCachingEnabled())
154 {
155 this.__notAllowedTitleKey1aSet = true;
156 }
157 }
158 return notAllowedTitleKey1a;
159 }
160
161 /**
162 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsTrigger#getTitleKey()
163 * @return String
164 */
165 protected abstract String handleGetTitleKey();
166
167 private String __titleKey2a;
168 private boolean __titleKey2aSet = false;
169
170 /**
171 * The message title key to use as a tooltip for this trigger.
172 * @return (String)handleGetTitleKey()
173 */
174 public final String getTitleKey()
175 {
176 String titleKey2a = this.__titleKey2a;
177 if (!this.__titleKey2aSet)
178 {
179 // titleKey has no pre constraints
180 titleKey2a = handleGetTitleKey();
181 // titleKey has no post constraints
182 this.__titleKey2a = titleKey2a;
183 if (isMetafacadePropertyCachingEnabled())
184 {
185 this.__titleKey2aSet = true;
186 }
187 }
188 return titleKey2a;
189 }
190
191 /**
192 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsTrigger#getResetTitleKey()
193 * @return String
194 */
195 protected abstract String handleGetResetTitleKey();
196
197 private String __resetTitleKey3a;
198 private boolean __resetTitleKey3aSet = false;
199
200 /**
201 * The message reset title key to use as a tooltip for this trigger's reset feature.
202 * @return (String)handleGetResetTitleKey()
203 */
204 public final String getResetTitleKey()
205 {
206 String resetTitleKey3a = this.__resetTitleKey3a;
207 if (!this.__resetTitleKey3aSet)
208 {
209 // resetTitleKey has no pre constraints
210 resetTitleKey3a = handleGetResetTitleKey();
211 // resetTitleKey has no post constraints
212 this.__resetTitleKey3a = resetTitleKey3a;
213 if (isMetafacadePropertyCachingEnabled())
214 {
215 this.__resetTitleKey3aSet = true;
216 }
217 }
218 return resetTitleKey3a;
219 }
220
221 /**
222 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsTrigger#getResetNotAllowedTitleKey()
223 * @return String
224 */
225 protected abstract String handleGetResetNotAllowedTitleKey();
226
227 private String __resetNotAllowedTitleKey4a;
228 private boolean __resetNotAllowedTitleKey4aSet = false;
229
230 /**
231 * Returns the message key to use as a tooltip when the user is not allowed to use reset the
232 * form behind this trigger.
233 * @return (String)handleGetResetNotAllowedTitleKey()
234 */
235 public final String getResetNotAllowedTitleKey()
236 {
237 String resetNotAllowedTitleKey4a = this.__resetNotAllowedTitleKey4a;
238 if (!this.__resetNotAllowedTitleKey4aSet)
239 {
240 // resetNotAllowedTitleKey has no pre constraints
241 resetNotAllowedTitleKey4a = handleGetResetNotAllowedTitleKey();
242 // resetNotAllowedTitleKey has no post constraints
243 this.__resetNotAllowedTitleKey4a = resetNotAllowedTitleKey4a;
244 if (isMetafacadePropertyCachingEnabled())
245 {
246 this.__resetNotAllowedTitleKey4aSet = true;
247 }
248 }
249 return resetNotAllowedTitleKey4a;
250 }
251
252 /**
253 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsTrigger#getTriggerKey()
254 * @return String
255 */
256 protected abstract String handleGetTriggerKey();
257
258 private String __triggerKey5a;
259 private boolean __triggerKey5aSet = false;
260
261 /**
262 * The message reset key for this trigger.
263 * @return (String)handleGetTriggerKey()
264 */
265 public final String getTriggerKey()
266 {
267 String triggerKey5a = this.__triggerKey5a;
268 if (!this.__triggerKey5aSet)
269 {
270 // triggerKey has no pre constraints
271 triggerKey5a = handleGetTriggerKey();
272 // triggerKey has no post constraints
273 this.__triggerKey5a = triggerKey5a;
274 if (isMetafacadePropertyCachingEnabled())
275 {
276 this.__triggerKey5aSet = true;
277 }
278 }
279 return triggerKey5a;
280 }
281
282 /**
283 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsTrigger#getTriggerValue()
284 * @return String
285 */
286 protected abstract String handleGetTriggerValue();
287
288 private String __triggerValue6a;
289 private boolean __triggerValue6aSet = false;
290
291 /**
292 * The resource message value for this trigger, this would be the button label or hyperlink
293 * name.
294 * @return (String)handleGetTriggerValue()
295 */
296 public final String getTriggerValue()
297 {
298 String triggerValue6a = this.__triggerValue6a;
299 if (!this.__triggerValue6aSet)
300 {
301 // triggerValue has no pre constraints
302 triggerValue6a = handleGetTriggerValue();
303 // triggerValue has no post constraints
304 this.__triggerValue6a = triggerValue6a;
305 if (isMetafacadePropertyCachingEnabled())
306 {
307 this.__triggerValue6aSet = true;
308 }
309 }
310 return triggerValue6a;
311 }
312
313 /**
314 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsTrigger#getTitleValue()
315 * @return String
316 */
317 protected abstract String handleGetTitleValue();
318
319 private String __titleValue7a;
320 private boolean __titleValue7aSet = false;
321
322 /**
323 * The default resource message value for this trigger's tooltip.
324 * @return (String)handleGetTitleValue()
325 */
326 public final String getTitleValue()
327 {
328 String titleValue7a = this.__titleValue7a;
329 if (!this.__titleValue7aSet)
330 {
331 // titleValue has no pre constraints
332 titleValue7a = handleGetTitleValue();
333 // titleValue has no post constraints
334 this.__titleValue7a = titleValue7a;
335 if (isMetafacadePropertyCachingEnabled())
336 {
337 this.__titleValue7aSet = true;
338 }
339 }
340 return titleValue7a;
341 }
342
343 /**
344 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsTrigger#getResetTitleValue()
345 * @return String
346 */
347 protected abstract String handleGetResetTitleValue();
348
349 private String __resetTitleValue8a;
350 private boolean __resetTitleValue8aSet = false;
351
352 /**
353 * The tooltip value for this trigger's reset feature.
354 * @return (String)handleGetResetTitleValue()
355 */
356 public final String getResetTitleValue()
357 {
358 String resetTitleValue8a = this.__resetTitleValue8a;
359 if (!this.__resetTitleValue8aSet)
360 {
361 // resetTitleValue has no pre constraints
362 resetTitleValue8a = handleGetResetTitleValue();
363 // resetTitleValue has no post constraints
364 this.__resetTitleValue8a = resetTitleValue8a;
365 if (isMetafacadePropertyCachingEnabled())
366 {
367 this.__resetTitleValue8aSet = true;
368 }
369 }
370 return resetTitleValue8a;
371 }
372
373 /**
374 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsTrigger#getResetNotAllowedTitleValue()
375 * @return String
376 */
377 protected abstract String handleGetResetNotAllowedTitleValue();
378
379 private String __resetNotAllowedTitleValue9a;
380 private boolean __resetNotAllowedTitleValue9aSet = false;
381
382 /**
383 * The message value to use as a tooltip when the user is not allowed to use reset the form
384 * behind this trigger.
385 * @return (String)handleGetResetNotAllowedTitleValue()
386 */
387 public final String getResetNotAllowedTitleValue()
388 {
389 String resetNotAllowedTitleValue9a = this.__resetNotAllowedTitleValue9a;
390 if (!this.__resetNotAllowedTitleValue9aSet)
391 {
392 // resetNotAllowedTitleValue has no pre constraints
393 resetNotAllowedTitleValue9a = handleGetResetNotAllowedTitleValue();
394 // resetNotAllowedTitleValue has no post constraints
395 this.__resetNotAllowedTitleValue9a = resetNotAllowedTitleValue9a;
396 if (isMetafacadePropertyCachingEnabled())
397 {
398 this.__resetNotAllowedTitleValue9aSet = true;
399 }
400 }
401 return resetNotAllowedTitleValue9a;
402 }
403
404 /**
405 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsTrigger#getNotAllowedTitleValue()
406 * @return String
407 */
408 protected abstract String handleGetNotAllowedTitleValue();
409
410 private String __notAllowedTitleValue10a;
411 private boolean __notAllowedTitleValue10aSet = false;
412
413 /**
414 * The message value to use as a tooltip when the user is not allowed to use this trigger.
415 * @return (String)handleGetNotAllowedTitleValue()
416 */
417 public final String getNotAllowedTitleValue()
418 {
419 String notAllowedTitleValue10a = this.__notAllowedTitleValue10a;
420 if (!this.__notAllowedTitleValue10aSet)
421 {
422 // notAllowedTitleValue has no pre constraints
423 notAllowedTitleValue10a = handleGetNotAllowedTitleValue();
424 // notAllowedTitleValue has no post constraints
425 this.__notAllowedTitleValue10a = notAllowedTitleValue10a;
426 if (isMetafacadePropertyCachingEnabled())
427 {
428 this.__notAllowedTitleValue10aSet = true;
429 }
430 }
431 return notAllowedTitleValue10a;
432 }
433
434 /**
435 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsTrigger#isActionTrigger()
436 * @return boolean
437 */
438 protected abstract boolean handleIsActionTrigger();
439
440 private boolean __actionTrigger11a;
441 private boolean __actionTrigger11aSet = false;
442
443 /**
444 * True if this trigger is modeled on an action transition. That means, the transition is coming
445 * out of an action state with the FrontEndView stereotype. False otherwise.
446 * @return (boolean)handleIsActionTrigger()
447 */
448 public final boolean isActionTrigger()
449 {
450 boolean actionTrigger11a = this.__actionTrigger11a;
451 if (!this.__actionTrigger11aSet)
452 {
453 // actionTrigger has no pre constraints
454 actionTrigger11a = handleIsActionTrigger();
455 // actionTrigger has no post constraints
456 this.__actionTrigger11a = actionTrigger11a;
457 if (isMetafacadePropertyCachingEnabled())
458 {
459 this.__actionTrigger11aSet = true;
460 }
461 }
462 return actionTrigger11a;
463 }
464
465 /**
466 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsTrigger#getResetMessageKey()
467 * @return String
468 */
469 protected abstract String handleGetResetMessageKey();
470
471 private String __resetMessageKey12a;
472 private boolean __resetMessageKey12aSet = false;
473
474 /**
475 * The message key to use for reset button labels.
476 * @return (String)handleGetResetMessageKey()
477 */
478 public final String getResetMessageKey()
479 {
480 String resetMessageKey12a = this.__resetMessageKey12a;
481 if (!this.__resetMessageKey12aSet)
482 {
483 // resetMessageKey has no pre constraints
484 resetMessageKey12a = handleGetResetMessageKey();
485 // resetMessageKey has no post constraints
486 this.__resetMessageKey12a = resetMessageKey12a;
487 if (isMetafacadePropertyCachingEnabled())
488 {
489 this.__resetMessageKey12aSet = true;
490 }
491 }
492 return resetMessageKey12a;
493 }
494
495 /**
496 * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsTrigger#getResetMessageValue()
497 * @return String
498 */
499 protected abstract String handleGetResetMessageValue();
500
501 private String __resetMessageValue13a;
502 private boolean __resetMessageValue13aSet = false;
503
504 /**
505 * The message value to use for reset button labels.
506 * @return (String)handleGetResetMessageValue()
507 */
508 public final String getResetMessageValue()
509 {
510 String resetMessageValue13a = this.__resetMessageValue13a;
511 if (!this.__resetMessageValue13aSet)
512 {
513 // resetMessageValue has no pre constraints
514 resetMessageValue13a = handleGetResetMessageValue();
515 // resetMessageValue has no post constraints
516 this.__resetMessageValue13a = resetMessageValue13a;
517 if (isMetafacadePropertyCachingEnabled())
518 {
519 this.__resetMessageValue13aSet = true;
520 }
521 }
522 return resetMessageValue13a;
523 }
524
525 // ------------- associations ------------------
526
527 private StrutsAction __getStrutsAction1r;
528 private boolean __getStrutsAction1rSet = false;
529
530 /**
531 * Returns the trigger that calls this action. Typically this is a button or an hyperlink.
532 * @return (StrutsAction)handleGetStrutsAction()
533 */
534 public final StrutsAction getStrutsAction()
535 {
536 StrutsAction getStrutsAction1r = this.__getStrutsAction1r;
537 if (!this.__getStrutsAction1rSet)
538 {
539 // actionTrigger has no pre constraints
540 Object result = handleGetStrutsAction();
541 MetafacadeBase shieldedResult = this.shieldedElement(result);
542 try
543 {
544 getStrutsAction1r = (StrutsAction)shieldedResult;
545 }
546 catch (ClassCastException ex)
547 {
548 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
549 StrutsTriggerLogic.logger.warn("incorrect metafacade cast for StrutsTriggerLogic.getStrutsAction StrutsAction " + result + ": " + shieldedResult);
550 }
551 // actionTrigger has no post constraints
552 this.__getStrutsAction1r = getStrutsAction1r;
553 if (isMetafacadePropertyCachingEnabled())
554 {
555 this.__getStrutsAction1rSet = true;
556 }
557 }
558 return getStrutsAction1r;
559 }
560
561 /**
562 * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
563 * @return Object
564 */
565 protected abstract Object handleGetStrutsAction();
566
567 /**
568 * @return true
569 * @see FrontEndEvent
570 */
571 public boolean isFrontEndEventMetaType()
572 {
573 return true;
574 }
575
576 /**
577 * @return true
578 * @see org.andromda.metafacades.uml.EventFacade
579 */
580 public boolean isEventFacadeMetaType()
581 {
582 return true;
583 }
584
585 /**
586 * @return true
587 * @see ModelElementFacade
588 */
589 public boolean isModelElementFacadeMetaType()
590 {
591 return true;
592 }
593
594 // ----------- delegates to FrontEndEvent ------------
595 /**
596 * The parameters to this event.
597 * @see org.andromda.metafacades.uml.EventFacade#getParameters()
598 */
599 public Collection<ParameterFacade> getParameters()
600 {
601 return this.getSuperFrontEndEvent().getParameters();
602 }
603
604 /**
605 * If this event is located on an action state, this will represent that state.
606 * @see org.andromda.metafacades.uml.EventFacade#getState()
607 */
608 public StateFacade getState()
609 {
610 return this.getSuperFrontEndEvent().getState();
611 }
612
613 /**
614 * If this event is located on a transition, this represents that transition.
615 * @see org.andromda.metafacades.uml.EventFacade#getTransition()
616 */
617 public TransitionFacade getTransition()
618 {
619 return this.getSuperFrontEndEvent().getTransition();
620 }
621
622 /**
623 * The action which triggers the "front-end" event.
624 * @see FrontEndEvent#getAction()
625 */
626 public FrontEndAction getAction()
627 {
628 return this.getSuperFrontEndEvent().getAction();
629 }
630
631 /**
632 * The call to the controller for this front-end event (if any).
633 * @see FrontEndEvent#getControllerCall()
634 */
635 public FrontEndControllerOperation getControllerCall()
636 {
637 return this.getSuperFrontEndEvent().getControllerCall();
638 }
639
640 /**
641 * Gets all controller operation calls for the front-end event.
642 * @see FrontEndEvent#getControllerCalls()
643 */
644 public List<FrontEndControllerOperation> getControllerCalls()
645 {
646 return this.getSuperFrontEndEvent().getControllerCalls();
647 }
648
649 /**
650 * Indicates whether or not this front end event is contained within a FrontEndUseCase.
651 * @see FrontEndEvent#isContainedInFrontEndUseCase()
652 */
653 public boolean isContainedInFrontEndUseCase()
654 {
655 return this.getSuperFrontEndEvent().isContainedInFrontEndUseCase();
656 }
657
658 /**
659 * Copies all tagged values from the given ModelElementFacade to this model element facade.
660 * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element)
661 */
662 public void copyTaggedValues(ModelElementFacade element)
663 {
664 this.getSuperFrontEndEvent().copyTaggedValues(element);
665 }
666
667 /**
668 * Finds the tagged value with the specified 'tagName'. In case there are more values the first
669 * one found will be returned.
670 * @see ModelElementFacade#findTaggedValue(String tagName)
671 */
672 public Object findTaggedValue(String tagName)
673 {
674 return this.getSuperFrontEndEvent().findTaggedValue(tagName);
675 }
676
677 /**
678 * Returns all the values for the tagged value with the specified name. The returned collection
679 * will contains only String instances, or will be empty. Never null.
680 * @see ModelElementFacade#findTaggedValues(String tagName)
681 */
682 public Collection<Object> findTaggedValues(String tagName)
683 {
684 return this.getSuperFrontEndEvent().findTaggedValues(tagName);
685 }
686
687 /**
688 * Returns the fully qualified name of the model element. The fully qualified name includes
689 * complete package qualified name of the underlying model element. The templates parameter will
690 * be replaced by the correct one given the binding relation of the parameter to this element.
691 * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement)
692 */
693 public String getBindedFullyQualifiedName(ModelElementFacade bindedElement)
694 {
695 return this.getSuperFrontEndEvent().getBindedFullyQualifiedName(bindedElement);
696 }
697
698 /**
699 * Gets all constraints belonging to the model element.
700 * @see ModelElementFacade#getConstraints()
701 */
702 public Collection<ConstraintFacade> getConstraints()
703 {
704 return this.getSuperFrontEndEvent().getConstraints();
705 }
706
707 /**
708 * Returns the constraints of the argument kind that have been placed onto this model. Typical
709 * kinds are "inv", "pre" and "post". Other kinds are possible.
710 * @see ModelElementFacade#getConstraints(String kind)
711 */
712 public Collection<ConstraintFacade> getConstraints(String kind)
713 {
714 return this.getSuperFrontEndEvent().getConstraints(kind);
715 }
716
717 /**
718 * Gets the documentation for the model element, The indent argument is prefixed to each line.
719 * By default this method wraps lines after 64 characters.
720 * This method is equivalent to <code>getDocumentation(indent, 64)</code>.
721 * @see ModelElementFacade#getDocumentation(String indent)
722 */
723 public String getDocumentation(String indent)
724 {
725 return this.getSuperFrontEndEvent().getDocumentation(indent);
726 }
727
728 /**
729 * This method returns the documentation for this model element, with the lines wrapped after
730 * the specified number of characters, values of less than 1 will indicate no line wrapping is
731 * required. By default paragraphs are returned as HTML.
732 * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>.
733 * @see ModelElementFacade#getDocumentation(String indent, int lineLength)
734 */
735 public String getDocumentation(String indent, int lineLength)
736 {
737 return this.getSuperFrontEndEvent().getDocumentation(indent, lineLength);
738 }
739
740 /**
741 * This method returns the documentation for this model element, with the lines wrapped after
742 * the specified number of characters, values of less than 1 will indicate no line wrapping is
743 * required. HTML style determines if HTML Escaping is applied.
744 * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle)
745 */
746 public String getDocumentation(String indent, int lineLength, boolean htmlStyle)
747 {
748 return this.getSuperFrontEndEvent().getDocumentation(indent, lineLength, htmlStyle);
749 }
750
751 /**
752 * The fully qualified name of this model element.
753 * @see ModelElementFacade#getFullyQualifiedName()
754 */
755 public String getFullyQualifiedName()
756 {
757 return this.getSuperFrontEndEvent().getFullyQualifiedName();
758 }
759
760 /**
761 * Returns the fully qualified name of the model element. The fully qualified name includes
762 * complete package qualified name of the underlying model element. If modelName is true, then
763 * the original name of the model element (the name contained within the model) will be the name
764 * returned, otherwise a name from a language mapping will be returned.
765 * @see ModelElementFacade#getFullyQualifiedName(boolean modelName)
766 */
767 public String getFullyQualifiedName(boolean modelName)
768 {
769 return this.getSuperFrontEndEvent().getFullyQualifiedName(modelName);
770 }
771
772 /**
773 * Returns the fully qualified name as a path, the returned value always starts with out a slash
774 * '/'.
775 * @see ModelElementFacade#getFullyQualifiedNamePath()
776 */
777 public String getFullyQualifiedNamePath()
778 {
779 return this.getSuperFrontEndEvent().getFullyQualifiedNamePath();
780 }
781
782 /**
783 * Gets the unique identifier of the underlying model element.
784 * @see ModelElementFacade#getId()
785 */
786 public String getId()
787 {
788 return this.getSuperFrontEndEvent().getId();
789 }
790
791 /**
792 * UML2: Retrieves the keywords for this element. Used to modify implementation properties which
793 * are not represented by other properties, i.e. native, transient, volatile, synchronized,
794 * (added annotations) override, deprecated. Can also be used to suppress compiler warnings:
795 * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require
796 * JDK5 compiler level.
797 * @see ModelElementFacade#getKeywords()
798 */
799 public Collection<String> getKeywords()
800 {
801 return this.getSuperFrontEndEvent().getKeywords();
802 }
803
804 /**
805 * UML2: Retrieves a localized label for this named element.
806 * @see ModelElementFacade#getLabel()
807 */
808 public String getLabel()
809 {
810 return this.getSuperFrontEndEvent().getLabel();
811 }
812
813 /**
814 * The language mappings that have been set for this model element.
815 * @see ModelElementFacade#getLanguageMappings()
816 */
817 public TypeMappings getLanguageMappings()
818 {
819 return this.getSuperFrontEndEvent().getLanguageMappings();
820 }
821
822 /**
823 * Return the model containing this model element (multiple models may be loaded and processed
824 * at the same time).
825 * @see ModelElementFacade#getModel()
826 */
827 public ModelFacade getModel()
828 {
829 return this.getSuperFrontEndEvent().getModel();
830 }
831
832 /**
833 * The name of the model element.
834 * @see ModelElementFacade#getName()
835 */
836 public String getName()
837 {
838 return this.getSuperFrontEndEvent().getName();
839 }
840
841 /**
842 * Gets the package to which this model element belongs.
843 * @see ModelElementFacade#getPackage()
844 */
845 public ModelElementFacade getPackage()
846 {
847 return this.getSuperFrontEndEvent().getPackage();
848 }
849
850 /**
851 * The name of this model element's package.
852 * @see ModelElementFacade#getPackageName()
853 */
854 public String getPackageName()
855 {
856 return this.getSuperFrontEndEvent().getPackageName();
857 }
858
859 /**
860 * Gets the package name (optionally providing the ability to retrieve the model name and not
861 * the mapped name).
862 * @see ModelElementFacade#getPackageName(boolean modelName)
863 */
864 public String getPackageName(boolean modelName)
865 {
866 return this.getSuperFrontEndEvent().getPackageName(modelName);
867 }
868
869 /**
870 * Returns the package as a path, the returned value always starts with out a slash '/'.
871 * @see ModelElementFacade#getPackagePath()
872 */
873 public String getPackagePath()
874 {
875 return this.getSuperFrontEndEvent().getPackagePath();
876 }
877
878 /**
879 * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the
880 * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from
881 * the names of the containing namespaces starting at the root of the hierarchy and ending with
882 * the name of the NamedElement itself.
883 * @see ModelElementFacade#getQualifiedName()
884 */
885 public String getQualifiedName()
886 {
887 return this.getSuperFrontEndEvent().getQualifiedName();
888 }
889
890 /**
891 * Gets the root package for the model element.
892 * @see ModelElementFacade#getRootPackage()
893 */
894 public PackageFacade getRootPackage()
895 {
896 return this.getSuperFrontEndEvent().getRootPackage();
897 }
898
899 /**
900 * Gets the dependencies for which this model element is the source.
901 * @see ModelElementFacade#getSourceDependencies()
902 */
903 public Collection<DependencyFacade> getSourceDependencies()
904 {
905 return this.getSuperFrontEndEvent().getSourceDependencies();
906 }
907
908 /**
909 * If this model element is the context of an activity graph, this represents that activity
910 * graph.
911 * @see ModelElementFacade#getStateMachineContext()
912 */
913 public StateMachineFacade getStateMachineContext()
914 {
915 return this.getSuperFrontEndEvent().getStateMachineContext();
916 }
917
918 /**
919 * The collection of ALL stereotype names for this model element.
920 * @see ModelElementFacade#getStereotypeNames()
921 */
922 public Collection<String> getStereotypeNames()
923 {
924 return this.getSuperFrontEndEvent().getStereotypeNames();
925 }
926
927 /**
928 * Gets all stereotypes for this model element.
929 * @see ModelElementFacade#getStereotypes()
930 */
931 public Collection<StereotypeFacade> getStereotypes()
932 {
933 return this.getSuperFrontEndEvent().getStereotypes();
934 }
935
936 /**
937 * Return the TaggedValues associated with this model element, under all stereotypes.
938 * @see ModelElementFacade#getTaggedValues()
939 */
940 public Collection<TaggedValueFacade> getTaggedValues()
941 {
942 return this.getSuperFrontEndEvent().getTaggedValues();
943 }
944
945 /**
946 * Gets the dependencies for which this model element is the target.
947 * @see ModelElementFacade#getTargetDependencies()
948 */
949 public Collection<DependencyFacade> getTargetDependencies()
950 {
951 return this.getSuperFrontEndEvent().getTargetDependencies();
952 }
953
954 /**
955 * Get the template parameter for this model element having the parameterName
956 * @see ModelElementFacade#getTemplateParameter(String parameterName)
957 */
958 public Object getTemplateParameter(String parameterName)
959 {
960 return this.getSuperFrontEndEvent().getTemplateParameter(parameterName);
961 }
962
963 /**
964 * Get the template parameters for this model element
965 * @see ModelElementFacade#getTemplateParameters()
966 */
967 public Collection<TemplateParameterFacade> getTemplateParameters()
968 {
969 return this.getSuperFrontEndEvent().getTemplateParameters();
970 }
971
972 /**
973 * The visibility (i.e. public, private, protected or package) of the model element, will
974 * attempt a lookup for these values in the language mappings (if any).
975 * @see ModelElementFacade#getVisibility()
976 */
977 public String getVisibility()
978 {
979 return this.getSuperFrontEndEvent().getVisibility();
980 }
981
982 /**
983 * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance
984 * is taken into account when searching for the stereotype), false otherwise.
985 * @see ModelElementFacade#hasExactStereotype(String stereotypeName)
986 */
987 public boolean hasExactStereotype(String stereotypeName)
988 {
989 return this.getSuperFrontEndEvent().hasExactStereotype(stereotypeName);
990 }
991
992 /**
993 * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma,
994 * pipe, semicolon, or << >>
995 * @see ModelElementFacade#hasKeyword(String keywordName)
996 */
997 public boolean hasKeyword(String keywordName)
998 {
999 return this.getSuperFrontEndEvent().hasKeyword(keywordName);
1000 }
1001
1002 /**
1003 * Returns true if the model element has the specified stereotype. If the stereotype itself
1004 * does not match, then a search will be made up the stereotype inheritance hierarchy, and if
1005 * one of the stereotype's ancestors has a matching name this method will return true, false
1006 * otherwise.
1007 * For example, if we have a certain stereotype called <<exception>> and a model element has a
1008 * stereotype called <<applicationException>> which extends <<exception>>, when calling this
1009 * method with 'stereotypeName' defined as 'exception' the method would return true since
1010 * <<applicationException>> inherits from <<exception>>. If you want to check if the model
1011 * element has the exact stereotype, then use the method 'hasExactStereotype' instead.
1012 * @see ModelElementFacade#hasStereotype(String stereotypeName)
1013 */
1014 public boolean hasStereotype(String stereotypeName)
1015 {
1016 return this.getSuperFrontEndEvent().hasStereotype(stereotypeName);
1017 }
1018
1019 /**
1020 * True if there are target dependencies from this element that are instances of BindingFacade.
1021 * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies.
1022 * @see ModelElementFacade#isBindingDependenciesPresent()
1023 */
1024 public boolean isBindingDependenciesPresent()
1025 {
1026 return this.getSuperFrontEndEvent().isBindingDependenciesPresent();
1027 }
1028
1029 /**
1030 * Indicates if any constraints are present on this model element.
1031 * @see ModelElementFacade#isConstraintsPresent()
1032 */
1033 public boolean isConstraintsPresent()
1034 {
1035 return this.getSuperFrontEndEvent().isConstraintsPresent();
1036 }
1037
1038 /**
1039 * Indicates if any documentation is present on this model element.
1040 * @see ModelElementFacade#isDocumentationPresent()
1041 */
1042 public boolean isDocumentationPresent()
1043 {
1044 return this.getSuperFrontEndEvent().isDocumentationPresent();
1045 }
1046
1047 /**
1048 * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript.
1049 * @see ModelElementFacade#isReservedWord()
1050 */
1051 public boolean isReservedWord()
1052 {
1053 return this.getSuperFrontEndEvent().isReservedWord();
1054 }
1055
1056 /**
1057 * True is there are template parameters on this model element. For UML2, applies to Class,
1058 * Operation, Property, and Parameter.
1059 * @see ModelElementFacade#isTemplateParametersPresent()
1060 */
1061 public boolean isTemplateParametersPresent()
1062 {
1063 return this.getSuperFrontEndEvent().isTemplateParametersPresent();
1064 }
1065
1066 /**
1067 * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++,
1068 * JavaScript. Contains no spaces, special characters etc. Constraint always applied on
1069 * Enumerations and Interfaces, optionally applies on other model elements.
1070 * @see ModelElementFacade#isValidIdentifierName()
1071 */
1072 public boolean isValidIdentifierName()
1073 {
1074 return this.getSuperFrontEndEvent().isValidIdentifierName();
1075 }
1076
1077 /**
1078 * Searches for the constraint with the specified 'name' on this model element, and if found
1079 * translates it using the specified 'translation' from a translation library discovered by the
1080 * framework.
1081 * @see ModelElementFacade#translateConstraint(String name, String translation)
1082 */
1083 public String translateConstraint(String name, String translation)
1084 {
1085 return this.getSuperFrontEndEvent().translateConstraint(name, translation);
1086 }
1087
1088 /**
1089 * Translates all constraints belonging to this model element with the given 'translation'.
1090 * @see ModelElementFacade#translateConstraints(String translation)
1091 */
1092 public String[] translateConstraints(String translation)
1093 {
1094 return this.getSuperFrontEndEvent().translateConstraints(translation);
1095 }
1096
1097 /**
1098 * Translates the constraints of the specified 'kind' belonging to this model element.
1099 * @see ModelElementFacade#translateConstraints(String kind, String translation)
1100 */
1101 public String[] translateConstraints(String kind, String translation)
1102 {
1103 return this.getSuperFrontEndEvent().translateConstraints(kind, translation);
1104 }
1105
1106 /**
1107 * @see MetafacadeBase#initialize()
1108 */
1109 @Override
1110 public void initialize()
1111 {
1112 this.getSuperFrontEndEvent().initialize();
1113 }
1114
1115 /**
1116 * @return Object getSuperFrontEndEvent().getValidationOwner()
1117 * @see MetafacadeBase#getValidationOwner()
1118 */
1119 @Override
1120 public Object getValidationOwner()
1121 {
1122 Object owner = this.getSuperFrontEndEvent().getValidationOwner();
1123 return owner;
1124 }
1125
1126 /**
1127 * @return String getSuperFrontEndEvent().getValidationName()
1128 * @see MetafacadeBase#getValidationName()
1129 */
1130 @Override
1131 public String getValidationName()
1132 {
1133 String name = this.getSuperFrontEndEvent().getValidationName();
1134 return name;
1135 }
1136
1137 /**
1138 * <p><b>Constraint:</b> org::andromda::cartridges::bpm4struts::metafacades::StrutsTrigger::each action trigger must have a name</p>
1139 * <p><b>Error:</b> Every trigger modeled on a transition going out of a FrontEndView action state must have a name. These triggers are known as action-triggers.</p>
1140 * <p><b>OCL:</b> context StrutsTrigger inv: transition.exitingPage implies name->notEmpty()</p>
1141 * @param validationMessages Collection<ModelValidationMessage>
1142 * @see MetafacadeBase#validateInvariants(Collection validationMessages)
1143 */
1144 @Override
1145 public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
1146 {
1147 this.getSuperFrontEndEvent().validateInvariants(validationMessages);
1148 try
1149 {
1150 final Object contextElement = this.THIS();
1151 boolean constraintValid = OCLResultEnsurer.ensure((Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"transition.exitingPage"))).booleanValue()?OCLCollections.notEmpty(OCLIntrospector.invoke(contextElement,"name")):true));
1152 if (!constraintValid)
1153 {
1154 validationMessages.add(
1155 new ModelValidationMessage(
1156 (MetafacadeBase)contextElement ,
1157 "org::andromda::cartridges::bpm4struts::metafacades::StrutsTrigger::each action trigger must have a name",
1158 "Every trigger modeled on a transition going out of a FrontEndView action state must have a name. These triggers are known as action-triggers."));
1159 }
1160 }
1161 catch (Throwable th)
1162 {
1163 Throwable cause = th.getCause();
1164 int depth = 0; // Some throwables have infinite recursion
1165 while (cause != null && depth < 7)
1166 {
1167 th = cause;
1168 depth++;
1169 }
1170 logger.error("Error validating constraint 'org::andromda::cartridges::bpm4struts::metafacades::StrutsTrigger::each action trigger must have a name' ON "
1171 + this.THIS().toString() + ": " + th.getMessage(), th);
1172 }
1173 }
1174
1175 /**
1176 * The property that stores the name of the metafacade.
1177 */
1178 private static final String NAME_PROPERTY = "name";
1179 private static final String FQNAME_PROPERTY = "fullyQualifiedName";
1180
1181 /**
1182 * @see Object#toString()
1183 */
1184 @Override
1185 public String toString()
1186 {
1187 final StringBuilder toString = new StringBuilder(this.getClass().getName());
1188 toString.append("[");
1189 try
1190 {
1191 toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY));
1192 }
1193 catch (final Throwable tryAgain)
1194 {
1195 try
1196 {
1197 toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY));
1198 }
1199 catch (final Throwable ignore)
1200 {
1201 // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property
1202 }
1203 }
1204 toString.append("]");
1205 return toString.toString();
1206 }
1207 }