Java tutorial
// license-header java merge-point // // Attention: generated code (by MetafacadeLogic.vsl) - do not modify! // package org.andromda.cartridges.gui.metafacades; import java.util.Collection; import java.util.List; import org.andromda.core.common.Introspector; import org.andromda.core.metafacade.MetafacadeBase; import org.andromda.core.metafacade.MetafacadeFactory; import org.andromda.core.metafacade.ModelValidationMessage; import org.andromda.metafacades.uml.AssociationEndFacade; import org.andromda.metafacades.uml.AttributeFacade; import org.andromda.metafacades.uml.ClassifierFacade; import org.andromda.metafacades.uml.ConstraintFacade; import org.andromda.metafacades.uml.DependencyFacade; import org.andromda.metafacades.uml.GeneralizableElementFacade; import org.andromda.metafacades.uml.GeneralizationFacade; import org.andromda.metafacades.uml.ModelElementFacade; import org.andromda.metafacades.uml.ModelFacade; import org.andromda.metafacades.uml.OperationFacade; import org.andromda.metafacades.uml.PackageFacade; import org.andromda.metafacades.uml.StateMachineFacade; import org.andromda.metafacades.uml.StereotypeFacade; import org.andromda.metafacades.uml.TaggedValueFacade; import org.andromda.metafacades.uml.TemplateParameterFacade; import org.andromda.metafacades.uml.TypeMappings; import org.andromda.translation.ocl.validation.OCLCollections; import org.andromda.translation.ocl.validation.OCLExpressions; import org.andromda.translation.ocl.validation.OCLIntrospector; import org.andromda.translation.ocl.validation.OCLResultEnsurer; import org.apache.commons.collections.Predicate; import org.apache.log4j.Logger; /** * TODO: Model Documentation for org.andromda.cartridges.gui.metafacades.GuiSessionObject * MetafacadeLogic for GuiSessionObject * * @see GuiSessionObject */ public abstract class GuiSessionObjectLogic extends MetafacadeBase implements GuiSessionObject { private static final long serialVersionUID = 1L; /** * The underlying UML object * @see Object */ protected transient Object metaObject; /** Create Metafacade implementation instance using the MetafacadeFactory from the context * @param metaObjectIn * @param context */ protected GuiSessionObjectLogic(final Object metaObjectIn, String context) { super(metaObjectIn, getContext(context)); this.superClassifierFacade = (ClassifierFacade) MetafacadeFactory.getInstance().createFacadeImpl( "org.andromda.metafacades.uml.ClassifierFacade", metaObjectIn, getContext(context)); this.metaObject = metaObjectIn; } /** * The logger instance. */ private static final Logger LOGGER = Logger.getLogger(GuiSessionObjectLogic.class); /** * Gets the context for this metafacade logic instance. * @param context String. Set to GuiSessionObject if null * @return context String */ private static String getContext(String context) { if (context == null) { context = "org.andromda.cartridges.gui.metafacades.GuiSessionObject"; } return context; } private ClassifierFacade superClassifierFacade; private boolean superClassifierFacadeInitialized = false; /** * Gets the ClassifierFacade parent instance. * @return this.superClassifierFacade ClassifierFacade */ private ClassifierFacade getSuperClassifierFacade() { if (!this.superClassifierFacadeInitialized) { ((MetafacadeBase) this.superClassifierFacade).setMetafacadeContext(this.getMetafacadeContext()); this.superClassifierFacadeInitialized = true; } return this.superClassifierFacade; } /** Reset context only for non-root metafacades * @param context * @see MetafacadeBase#resetMetafacadeContext(String context) */ @Override public void resetMetafacadeContext(String context) { if (!this.contextRoot) // reset context only for non-root metafacades { context = getContext(context); // to have same value as in original constructor call setMetafacadeContext(context); if (this.superClassifierFacadeInitialized) { ((MetafacadeBase) this.superClassifierFacade).resetMetafacadeContext(context); } } } /** * @return boolean true always * @see GuiSessionObject */ public boolean isGuiSessionObjectMetaType() { return true; } // --------------- attributes --------------------- /** * @see org.andromda.cartridges.gui.metafacades.GuiSessionObject#getFullPath() * @return String */ protected abstract String handleGetFullPath(); private transient String fullPath1a; private transient boolean fullPath1aSet = false; /** * The full path to the session object class file (comparable to the package name). * @return (String)handleGetFullPath() */ public final String getFullPath() { String fullPath1a = this.fullPath1a; if (!this.fullPath1aSet) { // fullPath has no pre constraints fullPath1a = handleGetFullPath(); // fullPath has no post constraints this.fullPath1a = fullPath1a; if (isMetafacadePropertyCachingEnabled()) { this.fullPath1aSet = true; } } return fullPath1a; } // ------------- associations ------------------ /** * @return true * @see ClassifierFacade */ public boolean isClassifierFacadeMetaType() { return true; } /** * @return true * @see GeneralizableElementFacade */ public boolean isGeneralizableElementFacadeMetaType() { return true; } /** * @return true * @see ModelElementFacade */ public boolean isModelElementFacadeMetaType() { return true; } // ----------- delegates to ClassifierFacade ------------ /** * Return the attribute which name matches the parameter * @see ClassifierFacade#findAttribute(String name) */ public AttributeFacade findAttribute(String name) { return this.getSuperClassifierFacade().findAttribute(name); } /** * Those abstraction dependencies for which this classifier is the client. * @see ClassifierFacade#getAbstractions() */ public Collection<ClassifierFacade> getAbstractions() { return this.getSuperClassifierFacade().getAbstractions(); } /** * Lists all classes associated to this one and any ancestor classes (through generalization). * There will be no duplicates. The order of the elements is predictable. * @see ClassifierFacade#getAllAssociatedClasses() */ public Collection<ClassifierFacade> getAllAssociatedClasses() { return this.getSuperClassifierFacade().getAllAssociatedClasses(); } /** * A collection containing all 'properties' of the classifier and its ancestors. Properties are * any attributes and navigable connecting association ends. * @see ClassifierFacade#getAllProperties() */ public Collection<ModelElementFacade> getAllProperties() { return this.getSuperClassifierFacade().getAllProperties(); } /** * A collection containing all required and/or read-only 'properties' of the classifier and its * ancestors. Properties are any attributes and navigable connecting association ends. * @see ClassifierFacade#getAllRequiredConstructorParameters() */ public Collection<ModelElementFacade> getAllRequiredConstructorParameters() { return this.getSuperClassifierFacade().getAllRequiredConstructorParameters(); } /** * Gets the array type for this classifier. If this classifier already represents an array, it * just returns itself. * @see ClassifierFacade#getArray() */ public ClassifierFacade getArray() { return this.getSuperClassifierFacade().getArray(); } /** * The name of the classifier as an array. * @see ClassifierFacade#getArrayName() */ public String getArrayName() { return this.getSuperClassifierFacade().getArrayName(); } /** * Lists the classes associated to this one, there is no repitition of classes. The order of the * elements is predictable. * @see ClassifierFacade#getAssociatedClasses() */ public Collection<ClassifierFacade> getAssociatedClasses() { return this.getSuperClassifierFacade().getAssociatedClasses(); } /** * Gets the association ends belonging to a classifier. * @see ClassifierFacade#getAssociationEnds() */ public List<AssociationEndFacade> getAssociationEnds() { return this.getSuperClassifierFacade().getAssociationEnds(); } /** * Gets the attributes that belong to the classifier. * @see ClassifierFacade#getAttributes() */ public List<AttributeFacade> getAttributes() { return this.getSuperClassifierFacade().getAttributes(); } /** * Gets all attributes for the classifier and if 'follow' is true goes up the inheritance * hierarchy and gets the attributes from the super classes as well. * @see ClassifierFacade#getAttributes(boolean follow) */ public List<AttributeFacade> getAttributes(boolean follow) { return this.getSuperClassifierFacade().getAttributes(follow); } /** * The fully qualified name of the classifier as an array. * @see ClassifierFacade#getFullyQualifiedArrayName() */ public String getFullyQualifiedArrayName() { return this.getSuperClassifierFacade().getFullyQualifiedArrayName(); } /** * Returns all those operations that could be implemented at this classifier's level. This means * the operations owned by this classifier as well as any realized interface's operations * (recursively) in case this classifier itself is not already an interface, or generalized when * this classifier is an interface. * @see ClassifierFacade#getImplementationOperations() */ public Collection<OperationFacade> getImplementationOperations() { return this.getSuperClassifierFacade().getImplementationOperations(); } /** * A comma separated list of the fully qualified names of all implemented interfaces. * @see ClassifierFacade#getImplementedInterfaceList() */ public String getImplementedInterfaceList() { return this.getSuperClassifierFacade().getImplementedInterfaceList(); } /** * Those attributes that are scoped to an instance of this class. * @see ClassifierFacade#getInstanceAttributes() */ public Collection<AttributeFacade> getInstanceAttributes() { return this.getSuperClassifierFacade().getInstanceAttributes(); } /** * Those operations that are scoped to an instance of this class. * @see ClassifierFacade#getInstanceOperations() */ public List<OperationFacade> getInstanceOperations() { return this.getSuperClassifierFacade().getInstanceOperations(); } /** * Those interfaces that are abstractions of this classifier, this basically means this * classifier realizes them. * @see ClassifierFacade#getInterfaceAbstractions() */ public Collection<ClassifierFacade> getInterfaceAbstractions() { return this.getSuperClassifierFacade().getInterfaceAbstractions(); } /** * A String representing a new Constructor declaration for this classifier type to be used in a * Java environment. * @see ClassifierFacade#getJavaNewString() */ public String getJavaNewString() { return this.getSuperClassifierFacade().getJavaNewString(); } /** * A String representing the null-value for this classifier type to be used in a Java * environment. * @see ClassifierFacade#getJavaNullString() */ public String getJavaNullString() { return this.getSuperClassifierFacade().getJavaNullString(); } /** * The other ends of this classifier's association ends which are navigable. * @see ClassifierFacade#getNavigableConnectingEnds() */ public Collection<AssociationEndFacade> getNavigableConnectingEnds() { return this.getSuperClassifierFacade().getNavigableConnectingEnds(); } /** * Get the other ends of this classifier's association ends which are navigable and if 'follow' * is true goes up the inheritance hierarchy and gets the super association ends as well. * @see ClassifierFacade#getNavigableConnectingEnds(boolean follow) */ public List<AssociationEndFacade> getNavigableConnectingEnds(boolean follow) { return this.getSuperClassifierFacade().getNavigableConnectingEnds(follow); } /** * Assuming that the classifier is an array, this will return the non array type of the * classifier from * the model. If the classifier is NOT an array, it will just return itself. * @see ClassifierFacade#getNonArray() */ public ClassifierFacade getNonArray() { return this.getSuperClassifierFacade().getNonArray(); } /** * The attributes from this classifier in the form of an operation call (this example would be * in Java): '(String attributeOne, String attributeTwo). If there were no attributes on the * classifier, the result would be an empty '()'. * @see ClassifierFacade#getOperationCallFromAttributes() */ public String getOperationCallFromAttributes() { return this.getSuperClassifierFacade().getOperationCallFromAttributes(); } /** * The operations owned by this classifier. * @see ClassifierFacade#getOperations() */ public List<OperationFacade> getOperations() { return this.getSuperClassifierFacade().getOperations(); } /** * A collection containing all 'properties' of the classifier. Properties are any attributes * and navigable connecting association ends. * @see ClassifierFacade#getProperties() */ public List<ModelElementFacade> getProperties() { return this.getSuperClassifierFacade().getProperties(); } /** * Gets all properties (attributes and navigable association ends) for the classifier and if * 'follow' is true goes up the inheritance hierarchy and gets the properties from the super * classes as well. * @see ClassifierFacade#getProperties(boolean follow) */ public List getProperties(boolean follow) { return this.getSuperClassifierFacade().getProperties(follow); } /** * A collection containing all required and/or read-only 'properties' of the classifier. * Properties are any attributes and navigable connecting association ends. * @see ClassifierFacade#getRequiredConstructorParameters() */ public Collection<ModelElementFacade> getRequiredConstructorParameters() { return this.getSuperClassifierFacade().getRequiredConstructorParameters(); } /** * Returns the serial version UID of the underlying model element. * @see ClassifierFacade#getSerialVersionUID() */ public long getSerialVersionUID() { return this.getSuperClassifierFacade().getSerialVersionUID(); } /** * Those attributes that are scoped to the definition of this class. * @see ClassifierFacade#getStaticAttributes() */ public Collection<AttributeFacade> getStaticAttributes() { return this.getSuperClassifierFacade().getStaticAttributes(); } /** * Those operations that are scoped to the definition of this class. * @see ClassifierFacade#getStaticOperations() */ public List<OperationFacade> getStaticOperations() { return this.getSuperClassifierFacade().getStaticOperations(); } /** * This class' superclass, returns the generalization if it is a ClassifierFacade, null * otherwise. * @see ClassifierFacade#getSuperClass() */ public ClassifierFacade getSuperClass() { return this.getSuperClassifierFacade().getSuperClass(); } /** * The wrapper name for this classifier if a mapped type has a defined wrapper class (ie. 'long' * maps to 'Long'). If the classifier doesn't have a wrapper defined for it, this method will * return a null. Note that wrapper mappings must be defined for the namespace by defining the * 'wrapperMappingsUri', this property must point to the location of the mappings file which * maps the primitives to wrapper types. * @see ClassifierFacade#getWrapperName() */ public String getWrapperName() { return this.getSuperClassifierFacade().getWrapperName(); } /** * Indicates if this classifier is 'abstract'. * @see ClassifierFacade#isAbstract() */ public boolean isAbstract() { return this.getSuperClassifierFacade().isAbstract(); } /** * True if this classifier represents an array type. False otherwise. * @see ClassifierFacade#isArrayType() */ public boolean isArrayType() { return this.getSuperClassifierFacade().isArrayType(); } /** * True if the ClassifierFacade is an AssociationClass. * @see ClassifierFacade#isAssociationClass() */ public boolean isAssociationClass() { return this.getSuperClassifierFacade().isAssociationClass(); } /** * Returns true if this type represents a Blob type. * @see ClassifierFacade#isBlobType() */ public boolean isBlobType() { return this.getSuperClassifierFacade().isBlobType(); } /** * Indicates if this type represents a boolean type or not. * @see ClassifierFacade#isBooleanType() */ public boolean isBooleanType() { return this.getSuperClassifierFacade().isBooleanType(); } /** * Indicates if this type represents a char, Character, or java.lang.Character type or not. * @see ClassifierFacade#isCharacterType() */ public boolean isCharacterType() { return this.getSuperClassifierFacade().isCharacterType(); } /** * Returns true if this type represents a Clob type. * @see ClassifierFacade#isClobType() */ public boolean isClobType() { return this.getSuperClassifierFacade().isClobType(); } /** * True if this classifier represents a collection type. False otherwise. * @see ClassifierFacade#isCollectionType() */ public boolean isCollectionType() { return this.getSuperClassifierFacade().isCollectionType(); } /** * True/false depending on whether or not this classifier represents a datatype. A data type is * a type whose instances are identified only by their value. A data type may contain attributes * to support the modeling of structured data types. * @see ClassifierFacade#isDataType() */ public boolean isDataType() { return this.getSuperClassifierFacade().isDataType(); } /** * True when this classifier is a date type. * @see ClassifierFacade#isDateType() */ public boolean isDateType() { return this.getSuperClassifierFacade().isDateType(); } /** * Indicates if this type represents a Double type or not. * @see ClassifierFacade#isDoubleType() */ public boolean isDoubleType() { return this.getSuperClassifierFacade().isDoubleType(); } /** * Indicates whether or not this classifier represents an "EmbeddedValue'. * @see ClassifierFacade#isEmbeddedValue() */ public boolean isEmbeddedValue() { return this.getSuperClassifierFacade().isEmbeddedValue(); } /** * True if this classifier is in fact marked as an enumeration. * @see ClassifierFacade#isEnumeration() */ public boolean isEnumeration() { return this.getSuperClassifierFacade().isEnumeration(); } /** * Returns true if this type represents a 'file' type. * @see ClassifierFacade#isFileType() */ public boolean isFileType() { return this.getSuperClassifierFacade().isFileType(); } /** * Indicates if this type represents a Float type or not. * @see ClassifierFacade#isFloatType() */ public boolean isFloatType() { return this.getSuperClassifierFacade().isFloatType(); } /** * Indicates if this type represents an int or Integer or java.lang.Integer type or not. * @see ClassifierFacade#isIntegerType() */ public boolean isIntegerType() { return this.getSuperClassifierFacade().isIntegerType(); } /** * True/false depending on whether or not this Classifier represents an interface. * @see ClassifierFacade#isInterface() */ public boolean isInterface() { return this.getSuperClassifierFacade().isInterface(); } /** * True if this classifier cannot be extended and represent a leaf in the inheritance tree. * @see ClassifierFacade#isLeaf() */ public boolean isLeaf() { return this.getSuperClassifierFacade().isLeaf(); } /** * True if this classifier represents a list type. False otherwise. * @see ClassifierFacade#isListType() */ public boolean isListType() { return this.getSuperClassifierFacade().isListType(); } /** * Indicates if this type represents a Long type or not. * @see ClassifierFacade#isLongType() */ public boolean isLongType() { return this.getSuperClassifierFacade().isLongType(); } /** * Indicates whether or not this classifier represents a Map type. * @see ClassifierFacade#isMapType() */ public boolean isMapType() { return this.getSuperClassifierFacade().isMapType(); } /** * Indicates whether or not this classifier represents a primitive type. * @see ClassifierFacade#isPrimitive() */ public boolean isPrimitive() { return this.getSuperClassifierFacade().isPrimitive(); } /** * True if this classifier represents a set type. False otherwise. * @see ClassifierFacade#isSetType() */ public boolean isSetType() { return this.getSuperClassifierFacade().isSetType(); } /** * Indicates whether or not this classifier represents a string type. * @see ClassifierFacade#isStringType() */ public boolean isStringType() { return this.getSuperClassifierFacade().isStringType(); } /** * Indicates whether or not this classifier represents a time type. * @see ClassifierFacade#isTimeType() */ public boolean isTimeType() { return this.getSuperClassifierFacade().isTimeType(); } /** * Returns true if this type is a wrapped primitive type. * @see ClassifierFacade#isWrappedPrimitive() */ public boolean isWrappedPrimitive() { return this.getSuperClassifierFacade().isWrappedPrimitive(); } /** * Finds the tagged value optional searching the entire inheritance hierarchy if 'follow' is set * to true. * @see GeneralizableElementFacade#findTaggedValue(String tagName, boolean follow) */ public Object findTaggedValue(String tagName, boolean follow) { return this.getSuperClassifierFacade().findTaggedValue(tagName, follow); } /** * All generalizations for this generalizable element, goes up the inheritance tree. * @see GeneralizableElementFacade#getAllGeneralizations() */ public Collection<GeneralizableElementFacade> getAllGeneralizations() { return this.getSuperClassifierFacade().getAllGeneralizations(); } /** * All specializations (travels down the inheritance hierarchy). * @see GeneralizableElementFacade#getAllSpecializations() */ public Collection<GeneralizableElementFacade> getAllSpecializations() { return this.getSuperClassifierFacade().getAllSpecializations(); } /** * Gets the direct generalization for this generalizable element. * @see GeneralizableElementFacade#getGeneralization() */ public GeneralizableElementFacade getGeneralization() { return this.getSuperClassifierFacade().getGeneralization(); } /** * Gets the actual links that this generalization element is part of (it plays either the * specialization or generalization). * @see GeneralizableElementFacade#getGeneralizationLinks() */ public Collection<GeneralizationFacade> getGeneralizationLinks() { return this.getSuperClassifierFacade().getGeneralizationLinks(); } /** * A comma separated list of the fully qualified names of all generalizations. * @see GeneralizableElementFacade#getGeneralizationList() */ public String getGeneralizationList() { return this.getSuperClassifierFacade().getGeneralizationList(); } /** * The element found when you recursively follow the generalization path up to the root. If an * element has no generalization itself will be considered the root. * @see GeneralizableElementFacade#getGeneralizationRoot() */ public GeneralizableElementFacade getGeneralizationRoot() { return this.getSuperClassifierFacade().getGeneralizationRoot(); } /** * The model element that represents an element that can be generalized or specialized. * @see GeneralizableElementFacade#getGeneralizations() */ public Collection<GeneralizableElementFacade> getGeneralizations() { return this.getSuperClassifierFacade().getGeneralizations(); } /** * Gets the direct specializations (i.e. sub elements) for this generalizatble element. * @see GeneralizableElementFacade#getSpecializations() */ public Collection<GeneralizableElementFacade> getSpecializations() { return this.getSuperClassifierFacade().getSpecializations(); } /** * Copies all tagged values from the given ModelElementFacade to this model element facade. * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element) */ public void copyTaggedValues(ModelElementFacade element) { this.getSuperClassifierFacade().copyTaggedValues(element); } /** * Finds the tagged value with the specified 'tagName'. In case there are more values the first * one found will be returned. * @see ModelElementFacade#findTaggedValue(String tagName) */ public Object findTaggedValue(String tagName) { return this.getSuperClassifierFacade().findTaggedValue(tagName); } /** * Returns all the values for the tagged value with the specified name. The returned collection * will contains only String instances, or will be empty. Never null. * @see ModelElementFacade#findTaggedValues(String tagName) */ public Collection<Object> findTaggedValues(String tagName) { return this.getSuperClassifierFacade().findTaggedValues(tagName); } /** * Returns the fully qualified name of the model element. The fully qualified name includes * complete package qualified name of the underlying model element. The templates parameter will * be replaced by the correct one given the binding relation of the parameter to this element. * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement) */ public String getBindedFullyQualifiedName(ModelElementFacade bindedElement) { return this.getSuperClassifierFacade().getBindedFullyQualifiedName(bindedElement); } /** * Gets all constraints belonging to the model element. * @see ModelElementFacade#getConstraints() */ public Collection<ConstraintFacade> getConstraints() { return this.getSuperClassifierFacade().getConstraints(); } /** * Returns the constraints of the argument kind that have been placed onto this model. Typical * kinds are "inv", "pre" and "post". Other kinds are possible. * @see ModelElementFacade#getConstraints(String kind) */ public Collection<ConstraintFacade> getConstraints(String kind) { return this.getSuperClassifierFacade().getConstraints(kind); } /** * Gets the documentation for the model element, The indent argument is prefixed to each line. * By default this method wraps lines after 64 characters. * This method is equivalent to <code>getDocumentation(indent, 64)</code>. * @see ModelElementFacade#getDocumentation(String indent) */ public String getDocumentation(String indent) { return this.getSuperClassifierFacade().getDocumentation(indent); } /** * This method returns the documentation for this model element, with the lines wrapped after * the specified number of characters, values of less than 1 will indicate no line wrapping is * required. By default paragraphs are returned as HTML. * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>. * @see ModelElementFacade#getDocumentation(String indent, int lineLength) */ public String getDocumentation(String indent, int lineLength) { return this.getSuperClassifierFacade().getDocumentation(indent, lineLength); } /** * This method returns the documentation for this model element, with the lines wrapped after * the specified number of characters, values of less than 1 will indicate no line wrapping is * required. HTML style determines if HTML Escaping is applied. * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle) */ public String getDocumentation(String indent, int lineLength, boolean htmlStyle) { return this.getSuperClassifierFacade().getDocumentation(indent, lineLength, htmlStyle); } /** * The fully qualified name of this model element. * @see ModelElementFacade#getFullyQualifiedName() */ public String getFullyQualifiedName() { return this.getSuperClassifierFacade().getFullyQualifiedName(); } /** * Returns the fully qualified name of the model element. The fully qualified name includes * complete package qualified name of the underlying model element. If modelName is true, then * the original name of the model element (the name contained within the model) will be the name * returned, otherwise a name from a language mapping will be returned. * @see ModelElementFacade#getFullyQualifiedName(boolean modelName) */ public String getFullyQualifiedName(boolean modelName) { return this.getSuperClassifierFacade().getFullyQualifiedName(modelName); } /** * Returns the fully qualified name as a path, the returned value always starts with out a slash * '/'. * @see ModelElementFacade#getFullyQualifiedNamePath() */ public String getFullyQualifiedNamePath() { return this.getSuperClassifierFacade().getFullyQualifiedNamePath(); } /** * Gets the unique identifier of the underlying model element. * @see ModelElementFacade#getId() */ public String getId() { return this.getSuperClassifierFacade().getId(); } /** * UML2: Retrieves the keywords for this element. Used to modify implementation properties which * are not represented by other properties, i.e. native, transient, volatile, synchronized, * (added annotations) override, deprecated. Can also be used to suppress compiler warnings: * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require * JDK5 compiler level. * @see ModelElementFacade#getKeywords() */ public Collection<String> getKeywords() { return this.getSuperClassifierFacade().getKeywords(); } /** * UML2: Retrieves a localized label for this named element. * @see ModelElementFacade#getLabel() */ public String getLabel() { return this.getSuperClassifierFacade().getLabel(); } /** * The language mappings that have been set for this model element. * @see ModelElementFacade#getLanguageMappings() */ public TypeMappings getLanguageMappings() { return this.getSuperClassifierFacade().getLanguageMappings(); } /** * Return the model containing this model element (multiple models may be loaded and processed * at the same time). * @see ModelElementFacade#getModel() */ public ModelFacade getModel() { return this.getSuperClassifierFacade().getModel(); } /** * The name of the model element. * @see ModelElementFacade#getName() */ public String getName() { return this.getSuperClassifierFacade().getName(); } /** * Gets the package to which this model element belongs. * @see ModelElementFacade#getPackage() */ public ModelElementFacade getPackage() { return this.getSuperClassifierFacade().getPackage(); } /** * The name of this model element's package. * @see ModelElementFacade#getPackageName() */ public String getPackageName() { return this.getSuperClassifierFacade().getPackageName(); } /** * Gets the package name (optionally providing the ability to retrieve the model name and not * the mapped name). * @see ModelElementFacade#getPackageName(boolean modelName) */ public String getPackageName(boolean modelName) { return this.getSuperClassifierFacade().getPackageName(modelName); } /** * Returns the package as a path, the returned value always starts with out a slash '/'. * @see ModelElementFacade#getPackagePath() */ public String getPackagePath() { return this.getSuperClassifierFacade().getPackagePath(); } /** * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from * the names of the containing namespaces starting at the root of the hierarchy and ending with * the name of the NamedElement itself. * @see ModelElementFacade#getQualifiedName() */ public String getQualifiedName() { return this.getSuperClassifierFacade().getQualifiedName(); } /** * Gets the root package for the model element. * @see ModelElementFacade#getRootPackage() */ public PackageFacade getRootPackage() { return this.getSuperClassifierFacade().getRootPackage(); } /** * Gets the dependencies for which this model element is the source. * @see ModelElementFacade#getSourceDependencies() */ public Collection<DependencyFacade> getSourceDependencies() { return this.getSuperClassifierFacade().getSourceDependencies(); } /** * If this model element is the context of an activity graph, this represents that activity * graph. * @see ModelElementFacade#getStateMachineContext() */ public StateMachineFacade getStateMachineContext() { return this.getSuperClassifierFacade().getStateMachineContext(); } /** * The collection of ALL stereotype names for this model element. * @see ModelElementFacade#getStereotypeNames() */ public Collection<String> getStereotypeNames() { return this.getSuperClassifierFacade().getStereotypeNames(); } /** * Gets all stereotypes for this model element. * @see ModelElementFacade#getStereotypes() */ public Collection<StereotypeFacade> getStereotypes() { return this.getSuperClassifierFacade().getStereotypes(); } /** * Return the TaggedValues associated with this model element, under all stereotypes. * @see ModelElementFacade#getTaggedValues() */ public Collection<TaggedValueFacade> getTaggedValues() { return this.getSuperClassifierFacade().getTaggedValues(); } /** * Gets the dependencies for which this model element is the target. * @see ModelElementFacade#getTargetDependencies() */ public Collection<DependencyFacade> getTargetDependencies() { return this.getSuperClassifierFacade().getTargetDependencies(); } /** * Get the template parameters for this model element. * @see ModelElementFacade#getTemplateParameter(String parameterName) */ public Object getTemplateParameter(String parameterName) { return this.getSuperClassifierFacade().getTemplateParameter(parameterName); } /** * Get the template parameter for this model element having the parameterName. * @see ModelElementFacade#getTemplateParameters() */ public Collection<TemplateParameterFacade> getTemplateParameters() { return this.getSuperClassifierFacade().getTemplateParameters(); } /** * The visibility (i.e. public, private, protected or package) of the model element, will * attempt a lookup for these values in the language mappings (if any). * @see ModelElementFacade#getVisibility() */ public String getVisibility() { return this.getSuperClassifierFacade().getVisibility(); } /** * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance * is taken into account when searching for the stereotype), false otherwise. * @see ModelElementFacade#hasExactStereotype(String stereotypeName) */ public boolean hasExactStereotype(String stereotypeName) { return this.getSuperClassifierFacade().hasExactStereotype(stereotypeName); } /** * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma, * pipe, semicolon, or << >> * @see ModelElementFacade#hasKeyword(String keywordName) */ public boolean hasKeyword(String keywordName) { return this.getSuperClassifierFacade().hasKeyword(keywordName); } /** * Returns true if the model element has the specified stereotype. If the stereotype itself * does not match, then a search will be made up the stereotype inheritance hierarchy, and if * one of the stereotype's ancestors has a matching name this method will return true, false * otherwise. * For example, if we have a certain stereotype called <<exception>> and a model element has a * stereotype called <<applicationException>> which extends <<exception>>, when calling this * method with 'stereotypeName' defined as 'exception' the method would return true since * <<applicationException>> inherits from <<exception>>. If you want to check if the model * element has the exact stereotype, then use the method 'hasExactStereotype' instead. * @see ModelElementFacade#hasStereotype(String stereotypeName) */ public boolean hasStereotype(String stereotypeName) { return this.getSuperClassifierFacade().hasStereotype(stereotypeName); } /** * True if there are target dependencies from this element that are instances of BindingFacade. * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies. * @see ModelElementFacade#isBindingDependenciesPresent() */ public boolean isBindingDependenciesPresent() { return this.getSuperClassifierFacade().isBindingDependenciesPresent(); } /** * Indicates if any constraints are present on this model element. * @see ModelElementFacade#isConstraintsPresent() */ public boolean isConstraintsPresent() { return this.getSuperClassifierFacade().isConstraintsPresent(); } /** * Indicates if any documentation is present on this model element. * @see ModelElementFacade#isDocumentationPresent() */ public boolean isDocumentationPresent() { return this.getSuperClassifierFacade().isDocumentationPresent(); } /** * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript. * @see ModelElementFacade#isReservedWord() */ public boolean isReservedWord() { return this.getSuperClassifierFacade().isReservedWord(); } /** * True is there are template parameters on this model element. For UML2, applies to Class, * Operation, Property, and Parameter. * @see ModelElementFacade#isTemplateParametersPresent() */ public boolean isTemplateParametersPresent() { return this.getSuperClassifierFacade().isTemplateParametersPresent(); } /** * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++, * JavaScript. Contains no spaces, special characters etc. Constraint always applied on * Enumerations and Interfaces, optionally applies on other model elements. * @see ModelElementFacade#isValidIdentifierName() */ public boolean isValidIdentifierName() { return this.getSuperClassifierFacade().isValidIdentifierName(); } /** * Searches for the constraint with the specified 'name' on this model element, and if found * translates it using the specified 'translation' from a translation library discovered by the * framework. * @see ModelElementFacade#translateConstraint(String name, String translation) */ public String translateConstraint(String name, String translation) { return this.getSuperClassifierFacade().translateConstraint(name, translation); } /** * Translates all constraints belonging to this model element with the given 'translation'. * @see ModelElementFacade#translateConstraints(String translation) */ public String[] translateConstraints(String translation) { return this.getSuperClassifierFacade().translateConstraints(translation); } /** * Translates the constraints of the specified 'kind' belonging to this model element. * @see ModelElementFacade#translateConstraints(String kind, String translation) */ public String[] translateConstraints(String kind, String translation) { return this.getSuperClassifierFacade().translateConstraints(kind, translation); } /** * @see MetafacadeBase#initialize() */ @Override public void initialize() { this.getSuperClassifierFacade().initialize(); } /** * @return Object getSuperClassifierFacade().getValidationOwner() * @see MetafacadeBase#getValidationOwner() */ @Override public Object getValidationOwner() { Object owner = this.getSuperClassifierFacade().getValidationOwner(); return owner; } /** * @return String getSuperClassifierFacade().getValidationName() * @see MetafacadeBase#getValidationName() */ @Override public String getValidationName() { String name = this.getSuperClassifierFacade().getValidationName(); return name; } /** * <p><b>Constraint:</b> org::andromda::cartridges::gui::metafacades::GuiSessionObject::session object needs a name</p> * <p><b>Error:</b> Each session object needs a good name, it will be used to look up the actual instance in the session scope.</p> * <p><b>OCL:</b> context GuiSessionObject inv: name->notEmpty()</p> * <p><b>Constraint:</b> org::andromda::cartridges::gui::metafacades::GuiSessionObject::session object needs public attributes</p> * <p><b>Error:</b> All attributes on a session object must have a public visibility.</p> * <p><b>OCL:</b> context GuiSessionObject inv : attributes -> forAll(visibility = 'public')</p> * @param validationMessages Collection<ModelValidationMessage> * @see MetafacadeBase#validateInvariants(Collection validationMessages) */ @Override public void validateInvariants(Collection<ModelValidationMessage> validationMessages) { this.getSuperClassifierFacade().validateInvariants(validationMessages); try { final Object contextElement = this.THIS(); boolean constraintValid = OCLResultEnsurer .ensure(OCLCollections.notEmpty(OCLIntrospector.invoke(contextElement, "name"))); if (!constraintValid) { validationMessages.add(new ModelValidationMessage((MetafacadeBase) contextElement, "org::andromda::cartridges::gui::metafacades::GuiSessionObject::session object needs a name", "Each session object needs a good name, it will be used to look up the actual instance in the session scope.")); } } catch (Throwable th) { Throwable cause = th.getCause(); int depth = 0; // Some throwables have infinite recursion while (cause != null && depth < 7) { th = cause; depth++; } logger.error( "Error validating constraint 'org::andromda::cartridges::gui::metafacades::GuiSessionObject::session object needs a name' ON " + this.THIS().toString() + ": " + th.getMessage(), th); } try { final Object contextElement = this.THIS(); boolean constraintValid = OCLResultEnsurer.ensure( OCLCollections.forAll(OCLIntrospector.invoke(contextElement, "attributes"), new Predicate() { public boolean evaluate(Object object) { return Boolean .valueOf(String.valueOf(OCLExpressions .equal(OCLIntrospector.invoke(object, "visibility"), "public"))) .booleanValue(); } })); if (!constraintValid) { validationMessages.add(new ModelValidationMessage((MetafacadeBase) contextElement, "org::andromda::cartridges::gui::metafacades::GuiSessionObject::session object needs public attributes", "All attributes on a session object must have a public visibility.")); } } catch (Throwable th) { Throwable cause = th.getCause(); int depth = 0; // Some throwables have infinite recursion while (cause != null && depth < 7) { th = cause; depth++; } logger.error( "Error validating constraint 'org::andromda::cartridges::gui::metafacades::GuiSessionObject::session object needs public attributes' ON " + this.THIS().toString() + ": " + th.getMessage(), th); } } /** * The property that stores the name of the metafacade. */ private static final String NAME_PROPERTY = "name"; private static final String FQNAME_PROPERTY = "fullyQualifiedName"; /** * @see Object#toString() */ @Override public String toString() { final StringBuilder toString = new StringBuilder(this.getClass().getName()); toString.append("["); try { toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY)); } catch (final Throwable tryAgain) { try { toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY)); } catch (final Throwable ignore) { // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property } } toString.append("]"); return toString.toString(); } }