Revision 177

View differences:

branches/modelio3.6.x/src/main/java/org/modelio/module/marte/profile/sw_concurrency/model/SwConcurrentResource_Class.java.bak
1
package org.modelio.marte.profile.sw_concurrency.model;
2

  
3
import java.util.List;
4

  
5
import org.modelio.api.modelio.Modelio;
6
import org.modelio.marte.api.MARTEStereotypes;
7
import org.modelio.marte.api.MARTETagTypes;
8
import org.modelio.marte.profile.sw_resourcecore.model.SwResource_Class;
9
import org.modelio.marte.profile.utils.MARTEResourceManager;
10
import org.modelio.marte.profile.utils.ModelUtils;
11
import org.modelio.metamodel.uml.infrastructure.Element;
12
import org.modelio.metamodel.uml.infrastructure.ModelTree;
13
import org.modelio.metamodel.uml.statik.Class;
14
import org.modelio.metamodel.uml.statik.TemplateParameter;
15

  
16

  
17
public class SwConcurrentResource_Class extends SwResource_Class{
18
    
19
    protected Class element;
20

  
21
 
22
    public SwConcurrentResource_Class() {
23
		super();        
24
Modelio.getInstance().getModelingSession().getModel().createClass();
25
        ModelUtils.setStereotype(element,MARTEStereotypes.SWCONCURRENTRESOURCE_CLASSIFIER);
26
        element.setName(MARTEResourceManager.getName(MARTEStereotypes.SWCONCURRENTRESOURCE_CLASSIFIER));
27
    }
28

  
29
    
30
    public SwConcurrentResource_Class(Class element) {
31
		super(element);
32
        this.element = element;
33
    }
34

  
35
    
36
    public Class getElement() {
37
        return element;
38
    }
39

  
40
    
41
    public void setParent(ModelTree parent) {
42
        element.setOwner(parent);
43
    }
44

  
45
    
46
    public void setParent(TemplateParameter parent) {
47
        element.setOwnerTemplateParameter(parent);
48
    }
49

  
50
    
51
    public String gettype() {
52
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_TYPE,element);
53
         if(res.equals("")){
54
         res = "";
55
        }
56
        return res;
57
    }
58

  
59
    
60
    public void settype(String value) {
61
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_TYPE, value);
62
    }
63

  
64
    
65
    public String getactivationCapacity() {
66
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_ACTIVATIONCAPACITY,element);
67
         if(res.equals("")){
68
         res = "";
69
        }
70
        return res;
71
    }
72

  
73
    
74
    public void setactivationCapacity(String value) {
75
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_ACTIVATIONCAPACITY, value);
76
    }
77

  
78
    
79
    public String getentryPoints() {
80
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_ENTRYPOINTS,element);
81
         if(res.equals("")){
82
         res = "";
83
        }
84
        return res;
85
    }
86

  
87
    
88
    public void setentryPoints(String value) {
89
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_ENTRYPOINTS, value);
90
    }
91

  
92
    
93
    public String getadressSpace() {
94
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_ADRESSSPACE,element);
95
         if(res.equals("")){
96
         res = "";
97
        }
98
        return res;
99
    }
100

  
101
    
102
    public void setadressSpace(String value) {
103
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_ADRESSSPACE, value);
104
    }
105

  
106
    
107
    public List<Element> getperiodElements() {
108
        return ModelUtils.getTargetElements(element, MARTEStereotypes.PROFILEASSOCIATION_PERIODELEMENTS_SWCONCURRENTRESOURCE);
109
    }
110

  
111

  
112
    
113
    public void setperiodElements(String value) {
114
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_PERIODELEMENTS, value);
115
    }
116

  
117
    
118
    public String getpriorityElements() {
119
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_PRIORITYELEMENTS,element);
120
         if(res.equals("")){
121
         res = "";
122
        }
123
        return res;
124
    }
125

  
126
    
127
    public void setpriorityElements(String value) {
128
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_PRIORITYELEMENTS, value);
129
    }
130

  
131
    
132
    public String getstackSizeElements() {
133
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_STACKSIZEELEMENTS,element);
134
         if(res.equals("")){
135
         res = "";
136
        }
137
        return res;
138
    }
139

  
140
    
141
    public void setstackSizeElements(String value) {
142
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_STACKSIZEELEMENTS, value);
143
    }
144

  
145
    
146
    public String getactivateServices() {
147
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_ACTIVATESERVICES,element);
148
         if(res.equals("")){
149
         res = "";
150
        }
151
        return res;
152
    }
153

  
154
    
155
    public void setactivateServices(String value) {
156
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_ACTIVATESERVICES, value);
157
    }
158

  
159
    
160
    public String getenableConcurrencyServices() {
161
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_ENABLECONCURRENCYSERVICES,element);
162
         if(res.equals("")){
163
         res = "";
164
        }
165
        return res;
166
    }
167

  
168
    
169
    public void setenableConcurrencyServices(String value) {
170
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_ENABLECONCURRENCYSERVICES, value);
171
    }
172

  
173
    
174
    public String getresumeServices() {
175
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_RESUMESERVICES,element);
176
         if(res.equals("")){
177
         res = "";
178
        }
179
        return res;
180
    }
181

  
182
    
183
    public void setresumeServices(String value) {
184
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_RESUMESERVICES, value);
185
    }
186

  
187
    
188
    public String getsuspendServices() {
189
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_SUSPENDSERVICES,element);
190
         if(res.equals("")){
191
         res = "";
192
        }
193
        return res;
194
    }
195

  
196
    
197
    public void setsuspendServices(String value) {
198
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_SUSPENDSERVICES, value);
199
    }
200

  
201
    
202
    public String getterminateServices() {
203
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_TERMINATESERVICES,element);
204
         if(res.equals("")){
205
         res = "";
206
        }
207
        return res;
208
    }
209

  
210
    
211
    public void setterminateServices(String value) {
212
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_TERMINATESERVICES, value);
213
    }
214

  
215
    
216
    public String getdisableConcurrencyServices() {
217
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_DISABLECONCURRENCYSERVICES,element);
218
         if(res.equals("")){
219
         res = "";
220
        }
221
        return res;
222
    }
223

  
224
    
225
    public void setdisableConcurrencyServices(String value) {
226
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_DISABLECONCURRENCYSERVICES, value);
227
    }
228

  
229
    
230
    public String getshareDataResources() {
231
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_SHAREDATARESOURCES,element);
232
         if(res.equals("")){
233
         res = "";
234
        }
235
        return res;
236
    }
237

  
238
    
239
    public void setshareDataResources(String value) {
240
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_SHAREDATARESOURCES, value);
241
    }
242

  
243
    
244
    public String getmessageResources() {
245
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_MESSAGERESOURCES,element);
246
         if(res.equals("")){
247
         res = "";
248
        }
249
        return res;
250
    }
251

  
252
    
253
    public void setmessageResources(String value) {
254
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_MESSAGERESOURCES, value);
255
    }
256

  
257
    
258
    public String getmutualExclusionResources() {
259
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_MUTUALEXCLUSIONRESOURCES,element);
260
         if(res.equals("")){
261
         res = "";
262
        }
263
        return res;
264
    }
265

  
266
    
267
    public void setmutualExclusionResources(String value) {
268
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_MUTUALEXCLUSIONRESOURCES, value);
269
    }
270

  
271
    
272
    public String getnotificationResources() {
273
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_NOTIFICATIONRESOURCES,element);
274
         if(res.equals("")){
275
         res = "";
276
        }
277
        return res;
278
    }
279

  
280
    
281
    public void setnotificationResources(String value) {
282
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_NOTIFICATIONRESOURCES, value);
283
    }
284

  
285
    
286
    public String getheapSizeElements() {
287
        String res = ModelUtils.getTaggedValue(MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_HEAPSIZEELEMENTS,element);
288
         if(res.equals("")){
289
         res = "";
290
        }
291
        return res;
292
    }
293

  
294
    
295
    public void setheapSizeElements(String value) {
296
        ModelUtils.addStringValue(element, MARTETagTypes.SWCONCURRENTRESOURCE_CLASSIFIER_SWCONCURRENTRESOURCE_CLASSIFIER_HEAPSIZEELEMENTS, value);
297
    }
298

  
299
}
branches/modelio3.6.x/pom.xml
5 5
  <!-- definition -->
6 6
  <groupId>org.modelio.module</groupId>
7 7
  <artifactId>martedesigner</artifactId>
8
  <version>3.6.00</version>
8
  <version>3.7.00</version>
9 9
  <name>MARTEDesigner</name>
10 10
  <repositories>
11 11
      <repository>
......
27 27
        <dependency>
28 28
            <groupId>org.modelio</groupId>
29 29
            <artifactId>MDAKit</artifactId>
30
            <version>[3.6.0,3.6.1)</version>
30
            <version>[3.7.0,3.7.1)</version>
31 31
            <type>pom</type>
32 32
            <scope>provided</scope>
33 33
        </dependency>

Also available in: Unified diff