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.ActionFacade;
14  import org.andromda.metafacades.uml.ConstraintFacade;
15  import org.andromda.metafacades.uml.DependencyFacade;
16  import org.andromda.metafacades.uml.EventFacade;
17  import org.andromda.metafacades.uml.FrontEndAction;
18  import org.andromda.metafacades.uml.FrontEndActionState;
19  import org.andromda.metafacades.uml.FrontEndExceptionHandler;
20  import org.andromda.metafacades.uml.FrontEndForward;
21  import org.andromda.metafacades.uml.ModelElementFacade;
22  import org.andromda.metafacades.uml.ModelFacade;
23  import org.andromda.metafacades.uml.OperationFacade;
24  import org.andromda.metafacades.uml.PackageFacade;
25  import org.andromda.metafacades.uml.PartitionFacade;
26  import org.andromda.metafacades.uml.StateFacade;
27  import org.andromda.metafacades.uml.StateMachineFacade;
28  import org.andromda.metafacades.uml.StereotypeFacade;
29  import org.andromda.metafacades.uml.TaggedValueFacade;
30  import org.andromda.metafacades.uml.TemplateParameterFacade;
31  import org.andromda.metafacades.uml.TransitionFacade;
32  import org.andromda.metafacades.uml.TypeMappings;
33  
34  /**
35   * A plain action state represents an operation on the server called by an action. Optionally an
36   * action state may defer operations to the controller.
37   * MetafacadeLogic for StrutsActionState
38   *
39   * @see StrutsActionState
40   */
41  public abstract class StrutsActionStateLogic
42      extends MetafacadeBase
43      implements StrutsActionState
44  {
45      /**
46       * The underlying UML object
47       * @see Object
48       */
49      protected Object metaObject;
50  
51      /** Create Metafacade implementation instance using the MetafacadeFactory from the context
52       * @param metaObjectIn
53       * @param context
54       */
55      protected StrutsActionStateLogic(Object metaObjectIn, String context)
56      {
57          super(metaObjectIn, getContext(context));
58          this.superFrontEndActionState =
59             (FrontEndActionState)
60              MetafacadeFactory.getInstance().createFacadeImpl(
61                      "org.andromda.metafacades.uml.FrontEndActionState",
62                      metaObjectIn,
63                      getContext(context));
64          this.metaObject = metaObjectIn;
65      }
66  
67      /**
68       * Gets the context for this metafacade logic instance.
69       * @param context String. Set to StrutsActionState if null
70       * @return context String
71       */
72      private static String getContext(String context)
73      {
74          if (context == null)
75          {
76              context = "org.andromda.cartridges.bpm4struts.metafacades.StrutsActionState";
77          }
78          return context;
79      }
80  
81      private FrontEndActionState superFrontEndActionState;
82      private boolean superFrontEndActionStateInitialized = false;
83  
84      /**
85       * Gets the FrontEndActionState parent instance.
86       * @return this.superFrontEndActionState FrontEndActionState
87       */
88      private FrontEndActionState getSuperFrontEndActionState()
89      {
90          if (!this.superFrontEndActionStateInitialized)
91          {
92              ((MetafacadeBase)this.superFrontEndActionState).setMetafacadeContext(this.getMetafacadeContext());
93              this.superFrontEndActionStateInitialized = true;
94          }
95          return this.superFrontEndActionState;
96      }
97  
98      /** Reset context only for non-root metafacades
99       * @param context
100      * @see org.andromda.core.metafacade.MetafacadeBase#resetMetafacadeContext(String context)
101      */
102     @Override
103     public void resetMetafacadeContext(String context)
104     {
105         if (!this.contextRoot) // reset context only for non-root metafacades
106         {
107             context = getContext(context);  // to have same value as in original constructor call
108             setMetafacadeContext (context);
109             if (this.superFrontEndActionStateInitialized)
110             {
111                 ((MetafacadeBase)this.superFrontEndActionState).resetMetafacadeContext(context);
112             }
113         }
114     }
115 
116     /**
117      * @return boolean true always
118      * @see StrutsActionState
119      */
120     public boolean isStrutsActionStateMetaType()
121     {
122         return true;
123     }
124 
125     // ------------- associations ------------------
126 
127     /**
128      * @return true
129      * @see FrontEndActionState
130      */
131     public boolean isFrontEndActionStateMetaType()
132     {
133         return true;
134     }
135 
136     /**
137      * @return true
138      * @see org.andromda.metafacades.uml.ActionStateFacade
139      */
140     public boolean isActionStateFacadeMetaType()
141     {
142         return true;
143     }
144 
145     /**
146      * @return true
147      * @see StateFacade
148      */
149     public boolean isStateFacadeMetaType()
150     {
151         return true;
152     }
153 
154     /**
155      * @return true
156      * @see org.andromda.metafacades.uml.StateVertexFacade
157      */
158     public boolean isStateVertexFacadeMetaType()
159     {
160         return true;
161     }
162 
163     /**
164      * @return true
165      * @see ModelElementFacade
166      */
167     public boolean isModelElementFacadeMetaType()
168     {
169         return true;
170     }
171 
172     // ----------- delegates to FrontEndActionState ------------
173     /**
174      * The entry action for this action state (if any).
175      * @see org.andromda.metafacades.uml.ActionStateFacade#getEntry()
176      */
177     public ActionFacade getEntry()
178     {
179         return this.getSuperFrontEndActionState().getEntry();
180     }
181 
182     /**
183      * The method name representing this action state.
184      * @see FrontEndActionState#getActionMethodName()
185      */
186     public String getActionMethodName()
187     {
188         return this.getSuperFrontEndActionState().getActionMethodName();
189     }
190 
191     /**
192      * The actions that pass through this action state.
193      * @see FrontEndActionState#getContainerActions()
194      */
195     public List<FrontEndAction> getContainerActions()
196     {
197         return this.getSuperFrontEndActionState().getContainerActions();
198     }
199 
200     /**
201      * All calls deferred to the controller by this action state.
202      * @see FrontEndActionState#getControllerCalls()
203      */
204     public List<OperationFacade> getControllerCalls()
205     {
206         return this.getSuperFrontEndActionState().getControllerCalls();
207     }
208 
209     /**
210      * All exceptions modelled on this action state.
211      * @see FrontEndActionState#getExceptions()
212      */
213     public List<FrontEndExceptionHandler> getExceptions()
214     {
215         return this.getSuperFrontEndActionState().getExceptions();
216     }
217 
218     /**
219      * The next transition, there can be only one transition going out of an action state, otherwise
220      * decision points should be used (triggers are not supported at the server-side).
221      * @see FrontEndActionState#getForward()
222      */
223     public FrontEndForward getForward()
224     {
225         return this.getSuperFrontEndActionState().getForward();
226     }
227 
228     /**
229      * All calls deferred to the services by this action state.
230      * @see FrontEndActionState#getServiceCalls()
231      */
232     public List<OperationFacade> getServiceCalls()
233     {
234         return this.getSuperFrontEndActionState().getServiceCalls();
235     }
236 
237     /**
238      * True if this element is contained in a FrontEndUseCase.
239      * @see FrontEndActionState#isContainedInFrontEndUseCase()
240      */
241     public boolean isContainedInFrontEndUseCase()
242     {
243         return this.getSuperFrontEndActionState().isContainedInFrontEndUseCase();
244     }
245 
246     /**
247      * Indicates whether or not this front end action state is server side. Pages, for example, are
248      * also action states but they return control to the client.
249      * @see FrontEndActionState#isServerSide()
250      */
251     public boolean isServerSide()
252     {
253         return this.getSuperFrontEndActionState().isServerSide();
254     }
255 
256     /**
257      * Copies all tagged values from the given ModelElementFacade to this model element facade.
258      * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element)
259      */
260     public void copyTaggedValues(ModelElementFacade element)
261     {
262         this.getSuperFrontEndActionState().copyTaggedValues(element);
263     }
264 
265     /**
266      * Finds the tagged value with the specified 'tagName'. In case there are more values the first
267      * one found will be returned.
268      * @see ModelElementFacade#findTaggedValue(String tagName)
269      */
270     public Object findTaggedValue(String tagName)
271     {
272         return this.getSuperFrontEndActionState().findTaggedValue(tagName);
273     }
274 
275     /**
276      * Returns all the values for the tagged value with the specified name. The returned collection
277      * will contains only String instances, or will be empty. Never null.
278      * @see ModelElementFacade#findTaggedValues(String tagName)
279      */
280     public Collection<Object> findTaggedValues(String tagName)
281     {
282         return this.getSuperFrontEndActionState().findTaggedValues(tagName);
283     }
284 
285     /**
286      * Returns the fully qualified name of the model element. The fully qualified name includes
287      * complete package qualified name of the underlying model element. The templates parameter will
288      * be replaced by the correct one given the binding relation of the parameter to this element.
289      * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement)
290      */
291     public String getBindedFullyQualifiedName(ModelElementFacade bindedElement)
292     {
293         return this.getSuperFrontEndActionState().getBindedFullyQualifiedName(bindedElement);
294     }
295 
296     /**
297      * Gets all constraints belonging to the model element.
298      * @see ModelElementFacade#getConstraints()
299      */
300     public Collection<ConstraintFacade> getConstraints()
301     {
302         return this.getSuperFrontEndActionState().getConstraints();
303     }
304 
305     /**
306      * Returns the constraints of the argument kind that have been placed onto this model. Typical
307      * kinds are "inv", "pre" and "post". Other kinds are possible.
308      * @see ModelElementFacade#getConstraints(String kind)
309      */
310     public Collection<ConstraintFacade> getConstraints(String kind)
311     {
312         return this.getSuperFrontEndActionState().getConstraints(kind);
313     }
314 
315     /**
316      * Gets the documentation for the model element, The indent argument is prefixed to each line.
317      * By default this method wraps lines after 64 characters.
318      * This method is equivalent to <code>getDocumentation(indent, 64)</code>.
319      * @see ModelElementFacade#getDocumentation(String indent)
320      */
321     public String getDocumentation(String indent)
322     {
323         return this.getSuperFrontEndActionState().getDocumentation(indent);
324     }
325 
326     /**
327      * This method returns the documentation for this model element, with the lines wrapped after
328      * the specified number of characters, values of less than 1 will indicate no line wrapping is
329      * required. By default paragraphs are returned as HTML.
330      * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>.
331      * @see ModelElementFacade#getDocumentation(String indent, int lineLength)
332      */
333     public String getDocumentation(String indent, int lineLength)
334     {
335         return this.getSuperFrontEndActionState().getDocumentation(indent, lineLength);
336     }
337 
338     /**
339      * This method returns the documentation for this model element, with the lines wrapped after
340      * the specified number of characters, values of less than 1 will indicate no line wrapping is
341      * required. HTML style determines if HTML Escaping is applied.
342      * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle)
343      */
344     public String getDocumentation(String indent, int lineLength, boolean htmlStyle)
345     {
346         return this.getSuperFrontEndActionState().getDocumentation(indent, lineLength, htmlStyle);
347     }
348 
349     /**
350      * The fully qualified name of this model element.
351      * @see ModelElementFacade#getFullyQualifiedName()
352      */
353     public String getFullyQualifiedName()
354     {
355         return this.getSuperFrontEndActionState().getFullyQualifiedName();
356     }
357 
358     /**
359      * Returns the fully qualified name of the model element. The fully qualified name includes
360      * complete package qualified name of the underlying model element.  If modelName is true, then
361      * the original name of the model element (the name contained within the model) will be the name
362      * returned, otherwise a name from a language mapping will be returned.
363      * @see ModelElementFacade#getFullyQualifiedName(boolean modelName)
364      */
365     public String getFullyQualifiedName(boolean modelName)
366     {
367         return this.getSuperFrontEndActionState().getFullyQualifiedName(modelName);
368     }
369 
370     /**
371      * Returns the fully qualified name as a path, the returned value always starts with out a slash
372      * '/'.
373      * @see ModelElementFacade#getFullyQualifiedNamePath()
374      */
375     public String getFullyQualifiedNamePath()
376     {
377         return this.getSuperFrontEndActionState().getFullyQualifiedNamePath();
378     }
379 
380     /**
381      * Gets the unique identifier of the underlying model element.
382      * @see ModelElementFacade#getId()
383      */
384     public String getId()
385     {
386         return this.getSuperFrontEndActionState().getId();
387     }
388 
389     /**
390      * UML2: Retrieves the keywords for this element. Used to modify implementation properties which
391      * are not represented by other properties, i.e. native, transient, volatile, synchronized,
392      * (added annotations) override, deprecated. Can also be used to suppress compiler warnings:
393      * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require
394      * JDK5 compiler level.
395      * @see ModelElementFacade#getKeywords()
396      */
397     public Collection<String> getKeywords()
398     {
399         return this.getSuperFrontEndActionState().getKeywords();
400     }
401 
402     /**
403      * UML2: Retrieves a localized label for this named element.
404      * @see ModelElementFacade#getLabel()
405      */
406     public String getLabel()
407     {
408         return this.getSuperFrontEndActionState().getLabel();
409     }
410 
411     /**
412      * The language mappings that have been set for this model element.
413      * @see ModelElementFacade#getLanguageMappings()
414      */
415     public TypeMappings getLanguageMappings()
416     {
417         return this.getSuperFrontEndActionState().getLanguageMappings();
418     }
419 
420     /**
421      * Return the model containing this model element (multiple models may be loaded and processed
422      * at the same time).
423      * @see ModelElementFacade#getModel()
424      */
425     public ModelFacade getModel()
426     {
427         return this.getSuperFrontEndActionState().getModel();
428     }
429 
430     /**
431      * The name of the model element.
432      * @see ModelElementFacade#getName()
433      */
434     public String getName()
435     {
436         return this.getSuperFrontEndActionState().getName();
437     }
438 
439     /**
440      * Gets the package to which this model element belongs.
441      * @see ModelElementFacade#getPackage()
442      */
443     public ModelElementFacade getPackage()
444     {
445         return this.getSuperFrontEndActionState().getPackage();
446     }
447 
448     /**
449      * The name of this model element's package.
450      * @see ModelElementFacade#getPackageName()
451      */
452     public String getPackageName()
453     {
454         return this.getSuperFrontEndActionState().getPackageName();
455     }
456 
457     /**
458      * Gets the package name (optionally providing the ability to retrieve the model name and not
459      * the mapped name).
460      * @see ModelElementFacade#getPackageName(boolean modelName)
461      */
462     public String getPackageName(boolean modelName)
463     {
464         return this.getSuperFrontEndActionState().getPackageName(modelName);
465     }
466 
467     /**
468      * Returns the package as a path, the returned value always starts with out a slash '/'.
469      * @see ModelElementFacade#getPackagePath()
470      */
471     public String getPackagePath()
472     {
473         return this.getSuperFrontEndActionState().getPackagePath();
474     }
475 
476     /**
477      * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the
478      * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from
479      * the names of the containing namespaces starting at the root of the hierarchy and ending with
480      * the name of the NamedElement itself.
481      * @see ModelElementFacade#getQualifiedName()
482      */
483     public String getQualifiedName()
484     {
485         return this.getSuperFrontEndActionState().getQualifiedName();
486     }
487 
488     /**
489      * Gets the root package for the model element.
490      * @see ModelElementFacade#getRootPackage()
491      */
492     public PackageFacade getRootPackage()
493     {
494         return this.getSuperFrontEndActionState().getRootPackage();
495     }
496 
497     /**
498      * Gets the dependencies for which this model element is the source.
499      * @see ModelElementFacade#getSourceDependencies()
500      */
501     public Collection<DependencyFacade> getSourceDependencies()
502     {
503         return this.getSuperFrontEndActionState().getSourceDependencies();
504     }
505 
506     /**
507      * If this model element is the context of an activity graph, this represents that activity
508      * graph.
509      * @see ModelElementFacade#getStateMachineContext()
510      */
511     public StateMachineFacade getStateMachineContext()
512     {
513         return this.getSuperFrontEndActionState().getStateMachineContext();
514     }
515 
516     /**
517      * The collection of ALL stereotype names for this model element.
518      * @see ModelElementFacade#getStereotypeNames()
519      */
520     public Collection<String> getStereotypeNames()
521     {
522         return this.getSuperFrontEndActionState().getStereotypeNames();
523     }
524 
525     /**
526      * Gets all stereotypes for this model element.
527      * @see ModelElementFacade#getStereotypes()
528      */
529     public Collection<StereotypeFacade> getStereotypes()
530     {
531         return this.getSuperFrontEndActionState().getStereotypes();
532     }
533 
534     /**
535      * Return the TaggedValues associated with this model element, under all stereotypes.
536      * @see ModelElementFacade#getTaggedValues()
537      */
538     public Collection<TaggedValueFacade> getTaggedValues()
539     {
540         return this.getSuperFrontEndActionState().getTaggedValues();
541     }
542 
543     /**
544      * Gets the dependencies for which this model element is the target.
545      * @see ModelElementFacade#getTargetDependencies()
546      */
547     public Collection<DependencyFacade> getTargetDependencies()
548     {
549         return this.getSuperFrontEndActionState().getTargetDependencies();
550     }
551 
552     /**
553      * Get the template parameter for this model element having the parameterName
554      * @see ModelElementFacade#getTemplateParameter(String parameterName)
555      */
556     public Object getTemplateParameter(String parameterName)
557     {
558         return this.getSuperFrontEndActionState().getTemplateParameter(parameterName);
559     }
560 
561     /**
562      * Get the template parameters for this model element
563      * @see ModelElementFacade#getTemplateParameters()
564      */
565     public Collection<TemplateParameterFacade> getTemplateParameters()
566     {
567         return this.getSuperFrontEndActionState().getTemplateParameters();
568     }
569 
570     /**
571      * The visibility (i.e. public, private, protected or package) of the model element, will
572      * attempt a lookup for these values in the language mappings (if any).
573      * @see ModelElementFacade#getVisibility()
574      */
575     public String getVisibility()
576     {
577         return this.getSuperFrontEndActionState().getVisibility();
578     }
579 
580     /**
581      * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance
582      * is taken into account when searching for the stereotype), false otherwise.
583      * @see ModelElementFacade#hasExactStereotype(String stereotypeName)
584      */
585     public boolean hasExactStereotype(String stereotypeName)
586     {
587         return this.getSuperFrontEndActionState().hasExactStereotype(stereotypeName);
588     }
589 
590     /**
591      * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma,
592      * pipe, semicolon, or << >>
593      * @see ModelElementFacade#hasKeyword(String keywordName)
594      */
595     public boolean hasKeyword(String keywordName)
596     {
597         return this.getSuperFrontEndActionState().hasKeyword(keywordName);
598     }
599 
600     /**
601      * Returns true if the model element has the specified stereotype.  If the stereotype itself
602      * does not match, then a search will be made up the stereotype inheritance hierarchy, and if
603      * one of the stereotype's ancestors has a matching name this method will return true, false
604      * otherwise.
605      * For example, if we have a certain stereotype called <<exception>> and a model element has a
606      * stereotype called <<applicationException>> which extends <<exception>>, when calling this
607      * method with 'stereotypeName' defined as 'exception' the method would return true since
608      * <<applicationException>> inherits from <<exception>>.  If you want to check if the model
609      * element has the exact stereotype, then use the method 'hasExactStereotype' instead.
610      * @see ModelElementFacade#hasStereotype(String stereotypeName)
611      */
612     public boolean hasStereotype(String stereotypeName)
613     {
614         return this.getSuperFrontEndActionState().hasStereotype(stereotypeName);
615     }
616 
617     /**
618      * True if there are target dependencies from this element that are instances of BindingFacade.
619      * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies.
620      * @see ModelElementFacade#isBindingDependenciesPresent()
621      */
622     public boolean isBindingDependenciesPresent()
623     {
624         return this.getSuperFrontEndActionState().isBindingDependenciesPresent();
625     }
626 
627     /**
628      * Indicates if any constraints are present on this model element.
629      * @see ModelElementFacade#isConstraintsPresent()
630      */
631     public boolean isConstraintsPresent()
632     {
633         return this.getSuperFrontEndActionState().isConstraintsPresent();
634     }
635 
636     /**
637      * Indicates if any documentation is present on this model element.
638      * @see ModelElementFacade#isDocumentationPresent()
639      */
640     public boolean isDocumentationPresent()
641     {
642         return this.getSuperFrontEndActionState().isDocumentationPresent();
643     }
644 
645     /**
646      * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript.
647      * @see ModelElementFacade#isReservedWord()
648      */
649     public boolean isReservedWord()
650     {
651         return this.getSuperFrontEndActionState().isReservedWord();
652     }
653 
654     /**
655      * True is there are template parameters on this model element. For UML2, applies to Class,
656      * Operation, Property, and Parameter.
657      * @see ModelElementFacade#isTemplateParametersPresent()
658      */
659     public boolean isTemplateParametersPresent()
660     {
661         return this.getSuperFrontEndActionState().isTemplateParametersPresent();
662     }
663 
664     /**
665      * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++,
666      * JavaScript. Contains no spaces, special characters etc. Constraint always applied on
667      * Enumerations and Interfaces, optionally applies on other model elements.
668      * @see ModelElementFacade#isValidIdentifierName()
669      */
670     public boolean isValidIdentifierName()
671     {
672         return this.getSuperFrontEndActionState().isValidIdentifierName();
673     }
674 
675     /**
676      * Searches for the constraint with the specified 'name' on this model element, and if found
677      * translates it using the specified 'translation' from a translation library discovered by the
678      * framework.
679      * @see ModelElementFacade#translateConstraint(String name, String translation)
680      */
681     public String translateConstraint(String name, String translation)
682     {
683         return this.getSuperFrontEndActionState().translateConstraint(name, translation);
684     }
685 
686     /**
687      * Translates all constraints belonging to this model element with the given 'translation'.
688      * @see ModelElementFacade#translateConstraints(String translation)
689      */
690     public String[] translateConstraints(String translation)
691     {
692         return this.getSuperFrontEndActionState().translateConstraints(translation);
693     }
694 
695     /**
696      * Translates the constraints of the specified 'kind' belonging to this model element.
697      * @see ModelElementFacade#translateConstraints(String kind, String translation)
698      */
699     public String[] translateConstraints(String kind, String translation)
700     {
701         return this.getSuperFrontEndActionState().translateConstraints(kind, translation);
702     }
703 
704     /**
705      * Events to which is being deferred in this action state.
706      * @see StateFacade#getDeferrableEvents()
707      */
708     public Collection<EventFacade> getDeferrableEvents()
709     {
710         return this.getSuperFrontEndActionState().getDeferrableEvents();
711     }
712 
713     /**
714      * Models a situation during which some (usually implicit) invariant condition holds. The states
715      * of
716      * protocol state machines are exposed to the users of their context classifiers. A protocol
717      * state
718      * represents an exposed stable situation of its context classifier: when an instance of the
719      * classifier
720      * is not processing any operation, users of this instance can always know its state
721      * configuration.
722      * @see org.andromda.metafacades.uml.StateVertexFacade#getContainer()
723      */
724     public StateFacade getContainer()
725     {
726         return this.getSuperFrontEndActionState().getContainer();
727     }
728 
729     /**
730      * A directed relationship between a source vertex and a target vertex. It may be part of a
731      * compound
732      * transition, which takes the state machine from one state configuration to another,
733      * representing the
734      * complete response of the state machine to an occurrence of an event of a particular type.
735      * @see org.andromda.metafacades.uml.StateVertexFacade#getIncomings()
736      */
737     public Collection<TransitionFacade> getIncomings()
738     {
739         return this.getSuperFrontEndActionState().getIncomings();
740     }
741 
742     /**
743      * A directed relationship between a source vertex and a target vertex. It may be part of a
744      * compound
745      * transition, which takes the state machine from one state configuration to another,
746      * representing the
747      * complete response of the state machine to an occurrence of an event of a particular type.
748      * @see org.andromda.metafacades.uml.StateVertexFacade#getOutgoings()
749      */
750     public Collection<TransitionFacade> getOutgoings()
751     {
752         return this.getSuperFrontEndActionState().getOutgoings();
753     }
754 
755     /**
756      * The partition (if any) to which this vertex belongs.
757      * @see org.andromda.metafacades.uml.StateVertexFacade#getPartition()
758      */
759     public PartitionFacade getPartition()
760     {
761         return this.getSuperFrontEndActionState().getPartition();
762     }
763 
764     /**
765      * State machines can be used to express the behavior of part of a system. Behavior is modeled
766      * as a
767      * traversal of a graph of state nodes interconnected by one or more joined transition arcs that
768      * are
769      * triggered by the dispatching of series of (event) occurrences. During this traversal, the
770      * state
771      * machine executes a series of activities associated with various elements of the state
772      * machine.
773      * @see org.andromda.metafacades.uml.StateVertexFacade#getStateMachine()
774      */
775     public StateMachineFacade getStateMachine()
776     {
777         return this.getSuperFrontEndActionState().getStateMachine();
778     }
779 
780     /**
781      * @see org.andromda.core.metafacade.MetafacadeBase#initialize()
782      */
783     @Override
784     public void initialize()
785     {
786         this.getSuperFrontEndActionState().initialize();
787     }
788 
789     /**
790      * @return Object getSuperFrontEndActionState().getValidationOwner()
791      * @see org.andromda.core.metafacade.MetafacadeBase#getValidationOwner()
792      */
793     @Override
794     public Object getValidationOwner()
795     {
796         Object owner = this.getSuperFrontEndActionState().getValidationOwner();
797         return owner;
798     }
799 
800     /**
801      * @return String getSuperFrontEndActionState().getValidationName()
802      * @see org.andromda.core.metafacade.MetafacadeBase#getValidationName()
803      */
804     @Override
805     public String getValidationName()
806     {
807         String name = this.getSuperFrontEndActionState().getValidationName();
808         return name;
809     }
810 
811     /**
812      * @param validationMessages Collection<ModelValidationMessage>
813      * @see org.andromda.core.metafacade.MetafacadeBase#validateInvariants(Collection validationMessages)
814      */
815     @Override
816     public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
817     {
818         this.getSuperFrontEndActionState().validateInvariants(validationMessages);
819     }
820 
821     /**
822      * The property that stores the name of the metafacade.
823      */
824     private static final String NAME_PROPERTY = "name";
825     private static final String FQNAME_PROPERTY = "fullyQualifiedName";
826 
827     /**
828      * @see Object#toString()
829      */
830     @Override
831     public String toString()
832     {
833         final StringBuilder toString = new StringBuilder(this.getClass().getName());
834         toString.append("[");
835         try
836         {
837             toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY));
838         }
839         catch (final Throwable tryAgain)
840         {
841             try
842             {
843                 toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY));
844             }
845             catch (final Throwable ignore)
846             {
847                 // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property
848             }
849         }
850         toString.append("]");
851         return toString.toString();
852     }
853 }