View Javadoc
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 }