1
2
3
4 package org.andromda.metafacades.uml;
5
6 /***
7 * <p>
8 * Represents a Classifier model element
9 * </p>
10 *
11 * Metafacade interface to be used by AndroMDA cartridges.
12 */
13 public interface ClassifierFacade
14 extends org.andromda.metafacades.uml.GeneralizableElementFacade
15 {
16
17 /***
18 * Indicates the metafacade type (used for metafacade mappings).
19 *
20 * @return always <code>true</code>
21 */
22 public boolean isClassifierFacadeMetaType();
23
24 /***
25 * <p>
26 * Return the attribute which name matches the parameter
27 * </p>
28 */
29 public org.andromda.metafacades.uml.AttributeFacade findAttribute(java.lang.String name);
30
31 /***
32 * <p>
33 * Those abstraction dependencies for which this classifier is the
34 * client.
35 * </p>
36 */
37 public java.util.Collection getAbstractions();
38
39 /***
40 * <p>
41 * Lists all classes associated to this one and any ancestor
42 * classes (through generalization). There will be no duplicates.
43 * The order of the elements is predictable.
44 * </p>
45 */
46 public java.util.Collection getAllAssociatedClasses();
47
48 /***
49 * <p>
50 * A collection containing all 'properties' of the classifier and
51 * its ancestors. Properties are any attributes and navigable
52 * connecting association ends.
53 * </p>
54 */
55 public java.util.Collection getAllProperties();
56
57 /***
58 * <p>
59 * A collection containing all required and/or read-only
60 * 'properties' of the classifier and its ancestors. Properties are
61 * any attributes and navigable connecting association ends.
62 * </p>
63 */
64 public java.util.Collection getAllRequiredConstructorParameters();
65
66 /***
67 * <p>
68 * Gets the array type for this classifier. If this classifier
69 * already represents an array, it just returns itself.
70 * </p>
71 */
72 public org.andromda.metafacades.uml.ClassifierFacade getArray();
73
74 /***
75 * <p>
76 * The name of the classifier as an array.
77 * </p>
78 */
79 public java.lang.String getArrayName();
80
81 /***
82 * <p>
83 * Lists the classes associated to this one, there is no repitition
84 * of classes. The order of the elements is predictable.
85 * </p>
86 */
87 public java.util.Collection getAssociatedClasses();
88
89 /***
90 * <p>
91 * Gets the association ends belonging to a classifier.
92 * </p>
93 */
94 public java.util.List getAssociationEnds();
95
96 /***
97 * <p>
98 * Gets the attributes that belong to the classifier.
99 * </p>
100 */
101 public java.util.Collection getAttributes();
102
103 /***
104 * <p>
105 * Gets all attributes for the classifier and if 'follow' is true
106 * goes up the inheritance hierachy and gets the attributes from
107 * the super classes as well.
108 * </p>
109 */
110 public java.util.Collection getAttributes(boolean follow);
111
112 /***
113 * <p>
114 * The fully qualified name of the classifier as an array.
115 * </p>
116 */
117 public java.lang.String getFullyQualifiedArrayName();
118
119 /***
120 * <p>
121 * Returns all those operations that could be implemented at this
122 * classifier's level. This means the operations owned by this
123 * classifier as well as any realized interface's operations
124 * (recursively) in case this classifier itself is not already an
125 * interface, or generalized when this classifier is an interface.
126 * </p>
127 */
128 public java.util.Collection getImplementationOperations();
129
130 /***
131 * <p>
132 * A comma seperated list of the fully qualified names of all
133 * implemented interfaces.
134 * </p>
135 */
136 public java.lang.String getImplementedInterfaceList();
137
138 /***
139 * <p>
140 * Those attributes that are scoped to an instance of this class.
141 * </p>
142 */
143 public java.util.Collection getInstanceAttributes();
144
145 /***
146 * <p>
147 * Those operations that are scoped to an instance of this class.
148 * </p>
149 */
150 public java.util.Collection getInstanceOperations();
151
152 /***
153 * <p>
154 * Those interfaces that are abstractions of this classifier, this
155 * basically means this classifier realizes them.
156 * </p>
157 */
158 public java.util.Collection getInterfaceAbstractions();
159
160 /***
161 * <p>
162 * A String representing the null-value for this classifier type to
163 * be used in a Java environment.
164 * </p>
165 */
166 public java.lang.String getJavaNullString();
167
168 /***
169 * <p>
170 * The other ends of this classifier's association ends which are
171 * navigable.
172 * </p>
173 */
174 public java.util.Collection getNavigableConnectingEnds();
175
176 /***
177 * <p>
178 * Get the other ends of this classifier's association ends which
179 * are navigable and if 'follow' is true goes up the inheritance
180 * hierarchy and gets the super association ends as well.
181 * </p>
182 */
183 public java.util.Collection getNavigableConnectingEnds(boolean follow);
184
185 /***
186 * <p>
187 * Assuming that the classifier is an array, this will return the
188 * non array type of the classifier from
189 * </p>
190 * <p>
191 * the model. If the classifier is NOT an array, it will just
192 * return itself.
193 * </p>
194 */
195 public org.andromda.metafacades.uml.ClassifierFacade getNonArray();
196
197 /***
198 * <p>
199 * The attributes from this classifier in the form of an operation
200 * call (this example would be in Java): '(java.lang.String
201 * attributeOne, java.lang.String attributeTwo). If there were no
202 * attributes on the classifier, the result would be an empty '()'.
203 * </p>
204 */
205 public java.lang.String getOperationCallFromAttributes();
206
207 /***
208 * <p>
209 * The operations owned by this classifier.
210 * </p>
211 */
212 public java.util.Collection getOperations();
213
214 /***
215 * <p>
216 * A collection containing all 'properties' of the classifier.
217 * Properties are any attributes and navigable connecting
218 * association ends.
219 * </p>
220 */
221 public java.util.Collection getProperties();
222
223 /***
224 * <p>
225 * Gets all properties (attributes and navigable association ends)
226 * for the classifier and if 'follow' is true goes up the
227 * inheritance hierachy and gets the properties from the super
228 * classes as well.
229 * </p>
230 */
231 public java.util.Collection getProperties(boolean follow);
232
233 /***
234 * <p>
235 * A collection containing all required and/or read-only
236 * 'properties' of the classifier. Properties are any attributes
237 * and navigable connecting association ends.
238 * </p>
239 */
240 public java.util.Collection getRequiredConstructorParameters();
241
242 /***
243 * <p>
244 * Returns the serial version UID of the underlying model element.
245 * </p>
246 */
247 public java.lang.Long getSerialVersionUID();
248
249 /***
250 * <p>
251 * Those attributes that are scoped to the definition of this
252 * class.
253 * </p>
254 */
255 public java.util.Collection getStaticAttributes();
256
257 /***
258 * <p>
259 * Those operations that are scoped to the definition of this
260 * class.
261 * </p>
262 */
263 public java.util.Collection getStaticOperations();
264
265 /***
266 * <p>
267 * This class' superclass, returns the generalization if it is a
268 * ClassifierFacade, null otherwise.
269 * </p>
270 */
271 public org.andromda.metafacades.uml.ClassifierFacade getSuperClass();
272
273 /***
274 * <p>
275 * The wrapper name for this classifier if a mapped type has a
276 * defined wrapper class (ie. 'long' maps to 'Long'). If the
277 * classifier doesn't have a wrapper defined for it, this method
278 * will return a null. Note that wrapper mappings must be defined
279 * for the namespace by defining the 'wrapperMappingsUri', this
280 * property must point to the location of the mappings file which
281 * maps the primitives to wrapper types.
282 * </p>
283 */
284 public java.lang.String getWrapperName();
285
286 /***
287 * <p>
288 * Indicates if this classifier is 'abstract'.
289 * </p>
290 */
291 public boolean isAbstract();
292
293 /***
294 * <p>
295 * True if this classifier represents an array type. False
296 * otherwise.
297 * </p>
298 */
299 public boolean isArrayType();
300
301 /***
302 *
303 */
304 public boolean isAssociationClass();
305
306 /***
307 * <p>
308 * Returns true if this type represents a Blob type.
309 * </p>
310 */
311 public boolean isBlobType();
312
313 /***
314 * <p>
315 * Indicates if this type represents a boolean type or not.
316 * </p>
317 */
318 public boolean isBooleanType();
319
320 /***
321 * <p>
322 * Returns true if this type represents a Clob type.
323 * </p>
324 */
325 public boolean isClobType();
326
327 /***
328 * <p>
329 * True if this classifier represents a collection type. False
330 * otherwise.
331 * </p>
332 */
333 public boolean isCollectionType();
334
335 /***
336 * <p>
337 * True/false depending on whether or not this classifier
338 * represents a datatype.
339 * </p>
340 */
341 public boolean isDataType();
342
343 /***
344 * <p>
345 * True when this classifier is a date type.
346 * </p>
347 */
348 public boolean isDateType();
349
350 /***
351 * <p>
352 * True if this classifier is in fact marked as an enumeration.
353 * </p>
354 */
355 public boolean isEnumeration();
356
357 /***
358 * <p>
359 * Returns true if this type represents a 'file' type.
360 * </p>
361 */
362 public boolean isFileType();
363
364 /***
365 * <p>
366 * True/false depending on whether or not this Classifier
367 * represents an interface.
368 * </p>
369 */
370 public boolean isInterface();
371
372 /***
373 * <p>
374 * True if this classifier cannot be extended and represent a leaf
375 * in the inheritance tree.
376 * </p>
377 */
378 public boolean isLeaf();
379
380 /***
381 * <p>
382 * True if this classifier represents a list type. False otherwise.
383 * </p>
384 */
385 public boolean isListType();
386
387 /***
388 * <p>
389 * Indicates whether or not this classifier represents a Map type.
390 * </p>
391 */
392 public boolean isMapType();
393
394 /***
395 * <p>
396 * Indicates whether or not this classifier represents a primitive
397 * type.
398 * </p>
399 */
400 public boolean isPrimitive();
401
402 /***
403 * <p>
404 * True if this classifier represents a set type. False otherwise.
405 * </p>
406 */
407 public boolean isSetType();
408
409 /***
410 * <p>
411 * Indicates whether or not this classifier represents a string
412 * type.
413 * </p>
414 */
415 public boolean isStringType();
416
417 /***
418 * <p>
419 * Indicates whether or not this classifier represents a time type.
420 * </p>
421 */
422 public boolean isTimeType();
423
424 }