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