001// license-header java merge-point
002//
003// Attention: generated code (by Metafacade.vsl) - do not modify!
004//
005package org.andromda.metafacades.uml;
006
007import java.util.Collection;
008import java.util.List;
009
010/**
011 * A Classifier is a classification of instances - it describes a set of instances that have
012 * features in common. Can specify a generalization hierarchy by referencing its general
013 * classifiers. It may be a Class, DataType, PrimitiveType, Association, Collaboration, UseCase,
014 * etc. Can specify a generalization hierarchy by referencing its general classifiers. Has the
015 * capability to own collaboration uses. These collaboration uses link a collaboration with the
016 * classifier to give a description of the workings of the classifier. Classifier is defined to be a
017 * kind of templateable element so that a classifier can be parameterized. It is also defined to be
018 * a kind of parameterable element so that a classifier can be a formal template parameter.
019 *
020 * Metafacade interface to be used by AndroMDA cartridges.
021 */
022public interface ClassifierFacade
023    extends GeneralizableElementFacade
024{
025    /**
026     * Indicates the metafacade type (used for metafacade mappings).
027     *
028     * @return boolean always <code>true</code>
029     */
030    public boolean isClassifierFacadeMetaType();
031
032    /**
033     * Return the attribute which name matches the parameter
034     * @param name String
035     * @return AttributeFacade
036     */
037    public AttributeFacade findAttribute(String name);
038
039    /**
040     * Those abstraction dependencies for which this classifier is the client.
041     * @return Collection<ClassifierFacade>
042     */
043    public Collection<ClassifierFacade> getAbstractions();
044
045    /**
046     * Lists all classes associated to this one and any ancestor classes (through generalization).
047     * There will be no duplicates. The order of the elements is predictable.
048     * @return Collection<ClassifierFacade>
049     */
050    public Collection<ClassifierFacade> getAllAssociatedClasses();
051
052    /**
053     * A collection containing all 'properties' of the classifier and its ancestors.  Properties are
054     * any attributes and navigable connecting association ends.
055     * @return Collection<ModelElementFacade>
056     */
057    public Collection<ModelElementFacade> getAllProperties();
058
059    /**
060     * A collection containing all required and/or read-only 'properties' of the classifier and its
061     * ancestors. Properties are any attributes and navigable connecting association ends.
062     * @return Collection<ModelElementFacade>
063     */
064    public Collection<ModelElementFacade> getAllRequiredConstructorParameters();
065
066    /**
067     * Gets the array type for this classifier.  If this classifier already represents an array, it
068     * just returns itself.
069     * @return ClassifierFacade
070     */
071    public ClassifierFacade getArray();
072
073    /**
074     * The name of the classifier as an array.
075     * @return String
076     */
077    public String getArrayName();
078
079    /**
080     * Lists the classes associated to this one, there is no repitition of classes. The order of the
081     * elements is predictable.
082     * @return Collection<ClassifierFacade>
083     */
084    public Collection<ClassifierFacade> getAssociatedClasses();
085
086    /**
087     * Gets the association ends belonging to a classifier.
088     * @return List<AssociationEndFacade>
089     */
090    public List<AssociationEndFacade> getAssociationEnds();
091
092    /**
093     * Gets the attributes that belong to the classifier.
094     * @return List<AttributeFacade>
095     */
096    public List<AttributeFacade> getAttributes();
097
098    /**
099     * 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}