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