1 // license-header java merge-point
2 //
3 // Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
4 //
5 package org.andromda.metafacades.uml14;
6
7 import java.util.Collection;
8 import org.andromda.core.metafacade.MetafacadeBase;
9 import org.andromda.core.metafacade.ModelValidationMessage;
10 import org.andromda.metafacades.uml.ActionFacade;
11 import org.andromda.metafacades.uml.ActionStateFacade;
12 import org.andromda.metafacades.uml.TransitionFacade;
13 import org.apache.log4j.Logger;
14 import org.omg.uml.behavioralelements.commonbehavior.Action;
15
16 /**
17 * An action is a named element that is the fundamental unit of executable functionality. The
18 * execution of an action represents some transformation or processing in the modeled system, be it
19 * a computer system or otherwise. An action represents a single step within an activity, that is,
20 * one that is not further decomposed within the activity. An action has pre- and post-conditions.
21 * MetafacadeLogic for ActionFacade
22 *
23 * @see ActionFacade
24 */
25 public abstract class ActionFacadeLogic
26 extends ModelElementFacadeLogicImpl
27 implements ActionFacade
28 {
29 /**
30 * The underlying UML object
31 * @see Action
32 */
33 protected Action metaObject;
34
35 /** Create Metafacade implementation instance using the MetafacadeFactory from the context
36 * @param metaObjectIn
37 * @param context
38 */
39 protected ActionFacadeLogic(Action metaObjectIn, String context)
40 {
41 super(metaObjectIn, getContext(context));
42 this.metaObject = metaObjectIn;
43 }
44
45 /**
46 * The logger instance.
47 */
48 private static final Logger logger = Logger.getLogger(ActionFacadeLogic.class);
49
50 /**
51 * Gets the context for this metafacade logic instance.
52 * @param context String. Set to ActionFacade if null
53 * @return context String
54 */
55 private static String getContext(String context)
56 {
57 if (context == null)
58 {
59 context = "org.andromda.metafacades.uml.ActionFacade";
60 }
61 return context;
62 }
63
64 /** Reset context only for non-root metafacades
65 * @param context
66 */
67 @Override
68 public void resetMetafacadeContext(String context)
69 {
70 if (!this.contextRoot) // reset context only for non-root metafacades
71 {
72 context = getContext(context); // to have same value as in original constructor call
73 setMetafacadeContext (context);
74 }
75 }
76
77 /**
78 * @return boolean true always
79 * @see ActionFacade
80 */
81 public boolean isActionFacadeMetaType()
82 {
83 return true;
84 }
85
86 // ------------- associations ------------------
87
88 private ActionStateFacade __getActionState1r;
89 private boolean __getActionState1rSet = false;
90
91 /**
92 * The entry action for this action state (if any).
93 * @return (ActionStateFacade)handleGetActionState()
94 */
95 public final ActionStateFacade getActionState()
96 {
97 ActionStateFacade getActionState1r = this.__getActionState1r;
98 if (!this.__getActionState1rSet)
99 {
100 // entry has no pre constraints
101 Object result = handleGetActionState();
102 MetafacadeBase shieldedResult = this.shieldedElement(result);
103 try
104 {
105 getActionState1r = (ActionStateFacade)shieldedResult;
106 }
107 catch (ClassCastException ex)
108 {
109 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
110 ActionFacadeLogic.logger.warn("incorrect metafacade cast for ActionFacadeLogic.getActionState ActionStateFacade " + result + ": " + shieldedResult);
111 }
112 // entry has no post constraints
113 this.__getActionState1r = getActionState1r;
114 if (isMetafacadePropertyCachingEnabled())
115 {
116 this.__getActionState1rSet = true;
117 }
118 }
119 return getActionState1r;
120 }
121
122 /**
123 * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
124 * @return Object
125 */
126 protected abstract Object handleGetActionState();
127
128 /**
129 * An action is a named element that is the fundamental unit of executable functionality. The
130 * execution
131 * of an action represents some transformation or processing in the modeled system, be it a
132 * computer
133 * system or otherwise. An action represents a single step within an activity, that is, one that
134 * is not
135 * further decomposed within the activity. An action has pre- and post-conditions.
136 * @return (TransitionFacade)handleGetTransition()
137 */
138 public final TransitionFacade getTransition()
139 {
140 TransitionFacade getTransition2r = null;
141 // effect has no pre constraints
142 Object result = handleGetTransition();
143 MetafacadeBase shieldedResult = this.shieldedElement(result);
144 try
145 {
146 getTransition2r = (TransitionFacade)shieldedResult;
147 }
148 catch (ClassCastException ex)
149 {
150 // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
151 ActionFacadeLogic.logger.warn("incorrect metafacade cast for ActionFacadeLogic.getTransition TransitionFacade " + result + ": " + shieldedResult);
152 }
153 // effect has no post constraints
154 return getTransition2r;
155 }
156
157 /**
158 * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
159 * @return Object
160 */
161 protected abstract Object handleGetTransition();
162
163 /**
164 * @param validationMessages Collection<ModelValidationMessage>
165 * @see ModelElementFacadeLogicImpl#validateInvariants(Collection validationMessages)
166 */
167 @Override
168 public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
169 {
170 super.validateInvariants(validationMessages);
171 }
172 }