ClassifierFacadeLogic.java
// license-header java merge-point
//
// Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
//
package org.andromda.metafacades.emf.uml22;
import java.util.Collection;
import java.util.List;
import org.andromda.core.metafacade.MetafacadeBase;
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.ModelElementFacade;
import org.andromda.metafacades.uml.OperationFacade;
import org.andromda.translation.ocl.validation.OCLCollections;
import org.andromda.translation.ocl.validation.OCLIntrospector;
import org.andromda.translation.ocl.validation.OCLResultEnsurer;
import org.apache.commons.collections.Transformer;
import org.apache.log4j.Logger;
import org.eclipse.uml2.uml.Classifier;
/**
* A Classifier is a classification of instances - it describes a set of instances that have
* features in common. Can specify a generalization hierarchy by referencing its general
* classifiers. It may be a Class, DataType, PrimitiveType, Association, Collaboration, UseCase,
* etc. Can specify a generalization hierarchy by referencing its general classifiers. Has the
* capability to own collaboration uses. These collaboration uses link a collaboration with the
* classifier to give a description of the workings of the classifier. Classifier is defined to be a
* kind of templateable element so that a classifier can be parameterized. It is also defined to be
* a kind of parameterable element so that a classifier can be a formal template parameter.
* MetafacadeLogic for ClassifierFacade
*
* @see ClassifierFacade
*/
public abstract class ClassifierFacadeLogic
extends GeneralizableElementFacadeLogicImpl
implements ClassifierFacade
{
/**
* The underlying UML object
* @see Classifier
*/
protected Classifier metaObject;
/** Create Metafacade implementation instance using the MetafacadeFactory from the context
* @param metaObjectIn
* @param context
*/
protected ClassifierFacadeLogic(Classifier metaObjectIn, String context)
{
super(metaObjectIn, getContext(context));
this.metaObject = metaObjectIn;
}
/**
* The logger instance.
*/
private static final Logger logger = Logger.getLogger(ClassifierFacadeLogic.class);
/**
* Gets the context for this metafacade logic instance.
* @param context String. Set to ClassifierFacade if null
* @return context String
*/
private static String getContext(String context)
{
if (context == null)
{
context = "org.andromda.metafacades.uml.ClassifierFacade";
}
return context;
}
/** Reset context only for non-root metafacades
* @param 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);
}
}
/**
* @return boolean true always
* @see ClassifierFacade
*/
public boolean isClassifierFacadeMetaType()
{
return true;
}
// --------------- attributes ---------------------
/**
* @see ClassifierFacade#isPrimitive()
* @return boolean
*/
protected abstract boolean handleIsPrimitive();
private boolean __primitive1a;
private boolean __primitive1aSet = false;
/**
* Indicates whether or not this classifier represents a primitive type.
* @return (boolean)handleIsPrimitive()
*/
public final boolean isPrimitive()
{
boolean primitive1a = this.__primitive1a;
if (!this.__primitive1aSet)
{
// primitive has no pre constraints
primitive1a = handleIsPrimitive();
// primitive has no post constraints
this.__primitive1a = primitive1a;
if (isMetafacadePropertyCachingEnabled())
{
this.__primitive1aSet = true;
}
}
return primitive1a;
}
/**
* @see ClassifierFacade#getOperationCallFromAttributes()
* @return String
*/
protected abstract String handleGetOperationCallFromAttributes();
private String __operationCallFromAttributes2a;
private boolean __operationCallFromAttributes2aSet = false;
/**
* 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 '()'.
* @return (String)handleGetOperationCallFromAttributes()
*/
public final String getOperationCallFromAttributes()
{
String operationCallFromAttributes2a = this.__operationCallFromAttributes2a;
if (!this.__operationCallFromAttributes2aSet)
{
// operationCallFromAttributes has no pre constraints
operationCallFromAttributes2a = handleGetOperationCallFromAttributes();
// operationCallFromAttributes has no post constraints
this.__operationCallFromAttributes2a = operationCallFromAttributes2a;
if (isMetafacadePropertyCachingEnabled())
{
this.__operationCallFromAttributes2aSet = true;
}
}
return operationCallFromAttributes2a;
}
/**
* @see ClassifierFacade#isAbstract()
* @return boolean
*/
protected abstract boolean handleIsAbstract();
private boolean __abstract3a;
private boolean __abstract3aSet = false;
/**
* Indicates if this classifier is 'abstract'.
* @return (boolean)handleIsAbstract()
*/
public final boolean isAbstract()
{
boolean abstract3a = this.__abstract3a;
if (!this.__abstract3aSet)
{
// abstract has no pre constraints
abstract3a = handleIsAbstract();
// abstract has no post constraints
this.__abstract3a = abstract3a;
if (isMetafacadePropertyCachingEnabled())
{
this.__abstract3aSet = true;
}
}
return abstract3a;
}
/**
* @see ClassifierFacade#isDataType()
* @return boolean
*/
protected abstract boolean handleIsDataType();
private boolean __dataType4a;
private boolean __dataType4aSet = false;
/**
* 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.
* @return (boolean)handleIsDataType()
*/
public final boolean isDataType()
{
boolean dataType4a = this.__dataType4a;
if (!this.__dataType4aSet)
{
// dataType has no pre constraints
dataType4a = handleIsDataType();
// dataType has no post constraints
this.__dataType4a = dataType4a;
if (isMetafacadePropertyCachingEnabled())
{
this.__dataType4aSet = true;
}
}
return dataType4a;
}
/**
* @see ClassifierFacade#isArrayType()
* @return boolean
*/
protected abstract boolean handleIsArrayType();
private boolean __arrayType5a;
private boolean __arrayType5aSet = false;
/**
* True if this classifier represents an array type. False otherwise.
* @return (boolean)handleIsArrayType()
*/
public final boolean isArrayType()
{
boolean arrayType5a = this.__arrayType5a;
if (!this.__arrayType5aSet)
{
// arrayType has no pre constraints
arrayType5a = handleIsArrayType();
// arrayType has no post constraints
this.__arrayType5a = arrayType5a;
if (isMetafacadePropertyCachingEnabled())
{
this.__arrayType5aSet = true;
}
}
return arrayType5a;
}
/**
* @see ClassifierFacade#isCollectionType()
* @return boolean
*/
protected abstract boolean handleIsCollectionType();
private boolean __collectionType6a;
private boolean __collectionType6aSet = false;
/**
* True if this classifier represents a collection type. False otherwise.
* @return (boolean)handleIsCollectionType()
*/
public final boolean isCollectionType()
{
boolean collectionType6a = this.__collectionType6a;
if (!this.__collectionType6aSet)
{
// collectionType has no pre constraints
collectionType6a = handleIsCollectionType();
// collectionType has no post constraints
this.__collectionType6a = collectionType6a;
if (isMetafacadePropertyCachingEnabled())
{
this.__collectionType6aSet = true;
}
}
return collectionType6a;
}
/**
* @see ClassifierFacade#getWrapperName()
* @return String
*/
protected abstract String handleGetWrapperName();
private String __wrapperName7a;
private boolean __wrapperName7aSet = false;
/**
* 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.
* @return (String)handleGetWrapperName()
*/
public final String getWrapperName()
{
String wrapperName7a = this.__wrapperName7a;
if (!this.__wrapperName7aSet)
{
// wrapperName has no pre constraints
wrapperName7a = handleGetWrapperName();
// wrapperName has no post constraints
this.__wrapperName7a = wrapperName7a;
if (isMetafacadePropertyCachingEnabled())
{
this.__wrapperName7aSet = true;
}
}
return wrapperName7a;
}
/**
* @see ClassifierFacade#isDateType()
* @return boolean
*/
protected abstract boolean handleIsDateType();
private boolean __dateType8a;
private boolean __dateType8aSet = false;
/**
* True when this classifier is a date type.
* @return (boolean)handleIsDateType()
*/
public final boolean isDateType()
{
boolean dateType8a = this.__dateType8a;
if (!this.__dateType8aSet)
{
// dateType has no pre constraints
dateType8a = handleIsDateType();
// dateType has no post constraints
this.__dateType8a = dateType8a;
if (isMetafacadePropertyCachingEnabled())
{
this.__dateType8aSet = true;
}
}
return dateType8a;
}
/**
* @see ClassifierFacade#isInterface()
* @return boolean
*/
protected abstract boolean handleIsInterface();
private boolean __interface9a;
private boolean __interface9aSet = false;
/**
* True/false depending on whether or not this Classifier represents an interface.
* @return (boolean)handleIsInterface()
*/
public final boolean isInterface()
{
boolean interface9a = this.__interface9a;
if (!this.__interface9aSet)
{
// interface has no pre constraints
interface9a = handleIsInterface();
// interface has no post constraints
this.__interface9a = interface9a;
if (isMetafacadePropertyCachingEnabled())
{
this.__interface9aSet = true;
}
}
return interface9a;
}
/**
* @see ClassifierFacade#getJavaNewString()
* @return String
*/
protected abstract String handleGetJavaNewString();
private String __javaNewString10a;
private boolean __javaNewString10aSet = false;
/**
* A String representing a new Constructor declaration for this classifier type to be used in a
* Java environment.
* @return (String)handleGetJavaNewString()
*/
public final String getJavaNewString()
{
String javaNewString10a = this.__javaNewString10a;
if (!this.__javaNewString10aSet)
{
// javaNewString has no pre constraints
javaNewString10a = handleGetJavaNewString();
// javaNewString has no post constraints
this.__javaNewString10a = javaNewString10a;
if (isMetafacadePropertyCachingEnabled())
{
this.__javaNewString10aSet = true;
}
}
return javaNewString10a;
}
/**
* @see ClassifierFacade#isListType()
* @return boolean
*/
protected abstract boolean handleIsListType();
private boolean __listType11a;
private boolean __listType11aSet = false;
/**
* True if this classifier represents a list type. False otherwise.
* @return (boolean)handleIsListType()
*/
public final boolean isListType()
{
boolean listType11a = this.__listType11a;
if (!this.__listType11aSet)
{
// listType has no pre constraints
listType11a = handleIsListType();
// listType has no post constraints
this.__listType11a = listType11a;
if (isMetafacadePropertyCachingEnabled())
{
this.__listType11aSet = true;
}
}
return listType11a;
}
/**
* @see ClassifierFacade#isSetType()
* @return boolean
*/
protected abstract boolean handleIsSetType();
private boolean __setType12a;
private boolean __setType12aSet = false;
/**
* True if this classifier represents a set type. False otherwise.
* @return (boolean)handleIsSetType()
*/
public final boolean isSetType()
{
boolean setType12a = this.__setType12a;
if (!this.__setType12aSet)
{
// setType has no pre constraints
setType12a = handleIsSetType();
// setType has no post constraints
this.__setType12a = setType12a;
if (isMetafacadePropertyCachingEnabled())
{
this.__setType12aSet = true;
}
}
return setType12a;
}
/**
* @see ClassifierFacade#isFileType()
* @return boolean
*/
protected abstract boolean handleIsFileType();
private boolean __fileType13a;
private boolean __fileType13aSet = false;
/**
* Returns true if this type represents a 'file' type.
* @return (boolean)handleIsFileType()
*/
public final boolean isFileType()
{
boolean fileType13a = this.__fileType13a;
if (!this.__fileType13aSet)
{
// fileType has no pre constraints
fileType13a = handleIsFileType();
// fileType has no post constraints
this.__fileType13a = fileType13a;
if (isMetafacadePropertyCachingEnabled())
{
this.__fileType13aSet = true;
}
}
return fileType13a;
}
/**
* @see ClassifierFacade#isMapType()
* @return boolean
*/
protected abstract boolean handleIsMapType();
private boolean __mapType14a;
private boolean __mapType14aSet = false;
/**
* Indicates whether or not this classifier represents a Map type.
* @return (boolean)handleIsMapType()
*/
public final boolean isMapType()
{
boolean mapType14a = this.__mapType14a;
if (!this.__mapType14aSet)
{
// mapType has no pre constraints
mapType14a = handleIsMapType();
// mapType has no post constraints
this.__mapType14a = mapType14a;
if (isMetafacadePropertyCachingEnabled())
{
this.__mapType14aSet = true;
}
}
return mapType14a;
}
/**
* @see ClassifierFacade#isStringType()
* @return boolean
*/
protected abstract boolean handleIsStringType();
private boolean __stringType15a;
private boolean __stringType15aSet = false;
/**
* Indicates whether or not this classifier represents a string type.
* @return (boolean)handleIsStringType()
*/
public final boolean isStringType()
{
boolean stringType15a = this.__stringType15a;
if (!this.__stringType15aSet)
{
// stringType has no pre constraints
stringType15a = handleIsStringType();
// stringType has no post constraints
this.__stringType15a = stringType15a;
if (isMetafacadePropertyCachingEnabled())
{
this.__stringType15aSet = true;
}
}
return stringType15a;
}
/**
* @see ClassifierFacade#isEnumeration()
* @return boolean
*/
protected abstract boolean handleIsEnumeration();
private boolean __enumeration16a;
private boolean __enumeration16aSet = false;
/**
* True if this classifier is in fact marked as an enumeration.
* @return (boolean)handleIsEnumeration()
*/
public final boolean isEnumeration()
{
boolean enumeration16a = this.__enumeration16a;
if (!this.__enumeration16aSet)
{
// enumeration has no pre constraints
enumeration16a = handleIsEnumeration();
// enumeration has no post constraints
this.__enumeration16a = enumeration16a;
if (isMetafacadePropertyCachingEnabled())
{
this.__enumeration16aSet = true;
}
}
return enumeration16a;
}
/**
* @see ClassifierFacade#getArrayName()
* @return String
*/
protected abstract String handleGetArrayName();
private String __arrayName17a;
private boolean __arrayName17aSet = false;
/**
* The name of the classifier as an array.
* @return (String)handleGetArrayName()
*/
public final String getArrayName()
{
String arrayName17a = this.__arrayName17a;
if (!this.__arrayName17aSet)
{
// arrayName has no pre constraints
arrayName17a = handleGetArrayName();
// arrayName has no post constraints
this.__arrayName17a = arrayName17a;
if (isMetafacadePropertyCachingEnabled())
{
this.__arrayName17aSet = true;
}
}
return arrayName17a;
}
/**
* @see ClassifierFacade#getFullyQualifiedArrayName()
* @return String
*/
protected abstract String handleGetFullyQualifiedArrayName();
private String __fullyQualifiedArrayName18a;
private boolean __fullyQualifiedArrayName18aSet = false;
/**
* The fully qualified name of the classifier as an array.
* @return (String)handleGetFullyQualifiedArrayName()
*/
public final String getFullyQualifiedArrayName()
{
String fullyQualifiedArrayName18a = this.__fullyQualifiedArrayName18a;
if (!this.__fullyQualifiedArrayName18aSet)
{
// fullyQualifiedArrayName has no pre constraints
fullyQualifiedArrayName18a = handleGetFullyQualifiedArrayName();
// fullyQualifiedArrayName has no post constraints
this.__fullyQualifiedArrayName18a = fullyQualifiedArrayName18a;
if (isMetafacadePropertyCachingEnabled())
{
this.__fullyQualifiedArrayName18aSet = true;
}
}
return fullyQualifiedArrayName18a;
}
/**
* @see ClassifierFacade#getSerialVersionUID()
* @return long
*/
protected abstract long handleGetSerialVersionUID();
private long __serialVersionUID19a;
private boolean __serialVersionUID19aSet = false;
/**
* Returns the serial version UID of the underlying model element.
* @return (long)handleGetSerialVersionUID()
*/
public final long getSerialVersionUID()
{
long serialVersionUID19a = this.__serialVersionUID19a;
if (!this.__serialVersionUID19aSet)
{
// serialVersionUID has no pre constraints
serialVersionUID19a = handleGetSerialVersionUID();
// serialVersionUID has no post constraints
this.__serialVersionUID19a = serialVersionUID19a;
if (isMetafacadePropertyCachingEnabled())
{
this.__serialVersionUID19aSet = true;
}
}
return serialVersionUID19a;
}
/**
* @see ClassifierFacade#isBlobType()
* @return boolean
*/
protected abstract boolean handleIsBlobType();
private boolean __blobType20a;
private boolean __blobType20aSet = false;
/**
* Returns true if this type represents a Blob type.
* @return (boolean)handleIsBlobType()
*/
public final boolean isBlobType()
{
boolean blobType20a = this.__blobType20a;
if (!this.__blobType20aSet)
{
// blobType has no pre constraints
blobType20a = handleIsBlobType();
// blobType has no post constraints
this.__blobType20a = blobType20a;
if (isMetafacadePropertyCachingEnabled())
{
this.__blobType20aSet = true;
}
}
return blobType20a;
}
/**
* @see ClassifierFacade#isBooleanType()
* @return boolean
*/
protected abstract boolean handleIsBooleanType();
private boolean __booleanType21a;
private boolean __booleanType21aSet = false;
/**
* Indicates if this type represents a boolean type or not.
* @return (boolean)handleIsBooleanType()
*/
public final boolean isBooleanType()
{
boolean booleanType21a = this.__booleanType21a;
if (!this.__booleanType21aSet)
{
// booleanType has no pre constraints
booleanType21a = handleIsBooleanType();
// booleanType has no post constraints
this.__booleanType21a = booleanType21a;
if (isMetafacadePropertyCachingEnabled())
{
this.__booleanType21aSet = true;
}
}
return booleanType21a;
}
/**
* @see ClassifierFacade#isTimeType()
* @return boolean
*/
protected abstract boolean handleIsTimeType();
private boolean __timeType22a;
private boolean __timeType22aSet = false;
/**
* Indicates whether or not this classifier represents a time type.
* @return (boolean)handleIsTimeType()
*/
public final boolean isTimeType()
{
boolean timeType22a = this.__timeType22a;
if (!this.__timeType22aSet)
{
// timeType has no pre constraints
timeType22a = handleIsTimeType();
// timeType has no post constraints
this.__timeType22a = timeType22a;
if (isMetafacadePropertyCachingEnabled())
{
this.__timeType22aSet = true;
}
}
return timeType22a;
}
/**
* @see ClassifierFacade#isLeaf()
* @return boolean
*/
protected abstract boolean handleIsLeaf();
private boolean __leaf23a;
private boolean __leaf23aSet = false;
/**
* True if this classifier cannot be extended and represent a leaf in the inheritance tree.
* @return (boolean)handleIsLeaf()
*/
public final boolean isLeaf()
{
boolean leaf23a = this.__leaf23a;
if (!this.__leaf23aSet)
{
// leaf has no pre constraints
leaf23a = handleIsLeaf();
// leaf has no post constraints
this.__leaf23a = leaf23a;
if (isMetafacadePropertyCachingEnabled())
{
this.__leaf23aSet = true;
}
}
return leaf23a;
}
/**
* @see ClassifierFacade#getImplementedInterfaceList()
* @return String
*/
protected abstract String handleGetImplementedInterfaceList();
private String __implementedInterfaceList24a;
private boolean __implementedInterfaceList24aSet = false;
/**
* A comma separated list of the fully qualified names of all implemented interfaces.
* @return (String)handleGetImplementedInterfaceList()
*/
public final String getImplementedInterfaceList()
{
String implementedInterfaceList24a = this.__implementedInterfaceList24a;
if (!this.__implementedInterfaceList24aSet)
{
// implementedInterfaceList has no pre constraints
implementedInterfaceList24a = handleGetImplementedInterfaceList();
// implementedInterfaceList has no post constraints
this.__implementedInterfaceList24a = implementedInterfaceList24a;
if (isMetafacadePropertyCachingEnabled())
{
this.__implementedInterfaceList24aSet = true;
}
}
return implementedInterfaceList24a;
}
/**
* @see ClassifierFacade#getRequiredConstructorParameters()
* @return Collection<ModelElementFacade>
*/
protected abstract Collection<ModelElementFacade> handleGetRequiredConstructorParameters();
private Collection<ModelElementFacade> __requiredConstructorParameters25a;
private boolean __requiredConstructorParameters25aSet = false;
/**
* A collection containing all required and/or read-only 'properties' of the classifier.
* Properties are any attributes and navigable connecting association ends.
* @return (Collection<ModelElementFacade>)handleGetRequiredConstructorParameters()
*/
public final Collection<ModelElementFacade> getRequiredConstructorParameters()
{
Collection<ModelElementFacade> requiredConstructorParameters25a = this.__requiredConstructorParameters25a;
if (!this.__requiredConstructorParameters25aSet)
{
// requiredConstructorParameters has no pre constraints
requiredConstructorParameters25a = handleGetRequiredConstructorParameters();
// requiredConstructorParameters has no post constraints
this.__requiredConstructorParameters25a = requiredConstructorParameters25a;
if (isMetafacadePropertyCachingEnabled())
{
this.__requiredConstructorParameters25aSet = true;
}
}
return requiredConstructorParameters25a;
}
/**
* @see ClassifierFacade#getAllRequiredConstructorParameters()
* @return Collection<ModelElementFacade>
*/
protected abstract Collection<ModelElementFacade> handleGetAllRequiredConstructorParameters();
private Collection<ModelElementFacade> __allRequiredConstructorParameters26a;
private boolean __allRequiredConstructorParameters26aSet = false;
/**
* 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.
* @return (Collection<ModelElementFacade>)handleGetAllRequiredConstructorParameters()
*/
public final Collection<ModelElementFacade> getAllRequiredConstructorParameters()
{
Collection<ModelElementFacade> allRequiredConstructorParameters26a = this.__allRequiredConstructorParameters26a;
if (!this.__allRequiredConstructorParameters26aSet)
{
// allRequiredConstructorParameters has no pre constraints
allRequiredConstructorParameters26a = handleGetAllRequiredConstructorParameters();
// allRequiredConstructorParameters has no post constraints
this.__allRequiredConstructorParameters26a = allRequiredConstructorParameters26a;
if (isMetafacadePropertyCachingEnabled())
{
this.__allRequiredConstructorParameters26aSet = true;
}
}
return allRequiredConstructorParameters26a;
}
/**
* @see ClassifierFacade#getProperties()
* @return List<ModelElementFacade>
*/
protected abstract List<ModelElementFacade> handleGetProperties();
private List<ModelElementFacade> __properties27a;
private boolean __properties27aSet = false;
/**
* A collection containing all 'properties' of the classifier. Properties are any attributes
* and navigable connecting association ends.
* @return (List<ModelElementFacade>)handleGetProperties()
*/
public final List<ModelElementFacade> getProperties()
{
List<ModelElementFacade> properties27a = this.__properties27a;
if (!this.__properties27aSet)
{
// properties has no pre constraints
properties27a = handleGetProperties();
// properties has no post constraints
this.__properties27a = properties27a;
if (isMetafacadePropertyCachingEnabled())
{
this.__properties27aSet = true;
}
}
return properties27a;
}
/**
* @see ClassifierFacade#getAllProperties()
* @return Collection<ModelElementFacade>
*/
protected abstract Collection<ModelElementFacade> handleGetAllProperties();
private Collection<ModelElementFacade> __allProperties28a;
private boolean __allProperties28aSet = false;
/**
* A collection containing all 'properties' of the classifier and its ancestors. Properties are
* any attributes and navigable connecting association ends.
* @return (Collection<ModelElementFacade>)handleGetAllProperties()
*/
public final Collection<ModelElementFacade> getAllProperties()
{
Collection<ModelElementFacade> allProperties28a = this.__allProperties28a;
if (!this.__allProperties28aSet)
{
// allProperties has no pre constraints
allProperties28a = handleGetAllProperties();
// allProperties has no post constraints
this.__allProperties28a = allProperties28a;
if (isMetafacadePropertyCachingEnabled())
{
this.__allProperties28aSet = true;
}
}
return allProperties28a;
}
/**
* @see ClassifierFacade#isAssociationClass()
* @return boolean
*/
protected abstract boolean handleIsAssociationClass();
private boolean __associationClass29a;
private boolean __associationClass29aSet = false;
/**
* True if the ClassifierFacade is an AssociationClass.
* @return (boolean)handleIsAssociationClass()
*/
public final boolean isAssociationClass()
{
boolean associationClass29a = this.__associationClass29a;
if (!this.__associationClass29aSet)
{
// associationClass has no pre constraints
associationClass29a = handleIsAssociationClass();
// associationClass has no post constraints
this.__associationClass29a = associationClass29a;
if (isMetafacadePropertyCachingEnabled())
{
this.__associationClass29aSet = true;
}
}
return associationClass29a;
}
/**
* @see ClassifierFacade#isClobType()
* @return boolean
*/
protected abstract boolean handleIsClobType();
private boolean __clobType30a;
private boolean __clobType30aSet = false;
/**
* Returns true if this type represents a Clob type.
* @return (boolean)handleIsClobType()
*/
public final boolean isClobType()
{
boolean clobType30a = this.__clobType30a;
if (!this.__clobType30aSet)
{
// clobType has no pre constraints
clobType30a = handleIsClobType();
// clobType has no post constraints
this.__clobType30a = clobType30a;
if (isMetafacadePropertyCachingEnabled())
{
this.__clobType30aSet = true;
}
}
return clobType30a;
}
/**
* @see ClassifierFacade#isEmbeddedValue()
* @return boolean
*/
protected abstract boolean handleIsEmbeddedValue();
private boolean __embeddedValue31a;
private boolean __embeddedValue31aSet = false;
/**
* Indicates whether or not this classifier represents an "EmbeddedValue'.
* @return (boolean)handleIsEmbeddedValue()
*/
public final boolean isEmbeddedValue()
{
boolean embeddedValue31a = this.__embeddedValue31a;
if (!this.__embeddedValue31aSet)
{
// embeddedValue has no pre constraints
embeddedValue31a = handleIsEmbeddedValue();
// embeddedValue has no post constraints
this.__embeddedValue31a = embeddedValue31a;
if (isMetafacadePropertyCachingEnabled())
{
this.__embeddedValue31aSet = true;
}
}
return embeddedValue31a;
}
/**
* @see ClassifierFacade#isIntegerType()
* @return boolean
*/
protected abstract boolean handleIsIntegerType();
private boolean __integerType32a;
private boolean __integerType32aSet = false;
/**
* Indicates if this type represents an int or Integer or java.lang.Integer type or not.
* @return (boolean)handleIsIntegerType()
*/
public final boolean isIntegerType()
{
boolean integerType32a = this.__integerType32a;
if (!this.__integerType32aSet)
{
// integerType has no pre constraints
integerType32a = handleIsIntegerType();
// integerType has no post constraints
this.__integerType32a = integerType32a;
if (isMetafacadePropertyCachingEnabled())
{
this.__integerType32aSet = true;
}
}
return integerType32a;
}
/**
* @see ClassifierFacade#isFloatType()
* @return boolean
*/
protected abstract boolean handleIsFloatType();
private boolean __floatType33a;
private boolean __floatType33aSet = false;
/**
* Indicates if this type represents a Float type or not.
* @return (boolean)handleIsFloatType()
*/
public final boolean isFloatType()
{
boolean floatType33a = this.__floatType33a;
if (!this.__floatType33aSet)
{
// floatType has no pre constraints
floatType33a = handleIsFloatType();
// floatType has no post constraints
this.__floatType33a = floatType33a;
if (isMetafacadePropertyCachingEnabled())
{
this.__floatType33aSet = true;
}
}
return floatType33a;
}
/**
* @see ClassifierFacade#isLongType()
* @return boolean
*/
protected abstract boolean handleIsLongType();
private boolean __longType34a;
private boolean __longType34aSet = false;
/**
* Indicates if this type represents a Long type or not.
* @return (boolean)handleIsLongType()
*/
public final boolean isLongType()
{
boolean longType34a = this.__longType34a;
if (!this.__longType34aSet)
{
// longType has no pre constraints
longType34a = handleIsLongType();
// longType has no post constraints
this.__longType34a = longType34a;
if (isMetafacadePropertyCachingEnabled())
{
this.__longType34aSet = true;
}
}
return longType34a;
}
/**
* @see ClassifierFacade#isDoubleType()
* @return boolean
*/
protected abstract boolean handleIsDoubleType();
private boolean __doubleType35a;
private boolean __doubleType35aSet = false;
/**
* Indicates if this type represents a Double type or not.
* @return (boolean)handleIsDoubleType()
*/
public final boolean isDoubleType()
{
boolean doubleType35a = this.__doubleType35a;
if (!this.__doubleType35aSet)
{
// doubleType has no pre constraints
doubleType35a = handleIsDoubleType();
// doubleType has no post constraints
this.__doubleType35a = doubleType35a;
if (isMetafacadePropertyCachingEnabled())
{
this.__doubleType35aSet = true;
}
}
return doubleType35a;
}
/**
* @see ClassifierFacade#isWrappedPrimitive()
* @return boolean
*/
protected abstract boolean handleIsWrappedPrimitive();
private boolean __wrappedPrimitive36a;
private boolean __wrappedPrimitive36aSet = false;
/**
* Returns true if this type is a wrapped primitive type.
* @return (boolean)handleIsWrappedPrimitive()
*/
public final boolean isWrappedPrimitive()
{
boolean wrappedPrimitive36a = this.__wrappedPrimitive36a;
if (!this.__wrappedPrimitive36aSet)
{
// wrappedPrimitive has no pre constraints
wrappedPrimitive36a = handleIsWrappedPrimitive();
// wrappedPrimitive has no post constraints
this.__wrappedPrimitive36a = wrappedPrimitive36a;
if (isMetafacadePropertyCachingEnabled())
{
this.__wrappedPrimitive36aSet = true;
}
}
return wrappedPrimitive36a;
}
/**
* @see ClassifierFacade#getJavaNullString()
* @return String
*/
protected abstract String handleGetJavaNullString();
private String __javaNullString37a;
private boolean __javaNullString37aSet = false;
/**
* A String representing the null-value for this classifier type to be used in a Java
* environment.
* @return (String)handleGetJavaNullString()
*/
public final String getJavaNullString()
{
String javaNullString37a = this.__javaNullString37a;
if (!this.__javaNullString37aSet)
{
// javaNullString has no pre constraints
javaNullString37a = handleGetJavaNullString();
// javaNullString has no post constraints
this.__javaNullString37a = javaNullString37a;
if (isMetafacadePropertyCachingEnabled())
{
this.__javaNullString37aSet = true;
}
}
return javaNullString37a;
}
/**
* @see ClassifierFacade#isCharacterType()
* @return boolean
*/
protected abstract boolean handleIsCharacterType();
private boolean __characterType38a;
private boolean __characterType38aSet = false;
/**
* Indicates if this type represents a char, Character, or java.lang.Character type or not.
* @return (boolean)handleIsCharacterType()
*/
public final boolean isCharacterType()
{
boolean characterType38a = this.__characterType38a;
if (!this.__characterType38aSet)
{
// characterType has no pre constraints
characterType38a = handleIsCharacterType();
// characterType has no post constraints
this.__characterType38a = characterType38a;
if (isMetafacadePropertyCachingEnabled())
{
this.__characterType38aSet = true;
}
}
return characterType38a;
}
// ---------------- business methods ----------------------
/**
* Method to be implemented in descendants
* 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.
* @param follow
* @return List<AttributeFacade>
*/
protected abstract List<AttributeFacade> handleGetAttributes(boolean follow);
/**
* 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.
* @param follow boolean
* Whether or not to follow the inheritance hierarchy when retrieveing attributes.
* @return handleGetAttributes(follow)
*/
public List<AttributeFacade> getAttributes(boolean follow)
{
// getAttributes has no pre constraints
List<AttributeFacade> returnValue = handleGetAttributes(follow);
// getAttributes has no post constraints
return returnValue;
}
/**
* Method to be implemented in descendants
* Return the attribute which name matches the parameter
* @param name
* @return AttributeFacade
*/
protected abstract AttributeFacade handleFindAttribute(String name);
/**
* Return the attribute which name matches the parameter
* @param name String
* TODO: Model Documentation for
* ClassifierFacade.findAttribute(name)
* @return handleFindAttribute(name)
*/
public AttributeFacade findAttribute(String name)
{
// findAttribute has no pre constraints
AttributeFacade returnValue = handleFindAttribute(name);
// findAttribute has no post constraints
return returnValue;
}
/**
* Method to be implemented in descendants
* 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.
* @param follow
* @return List
*/
protected abstract List handleGetProperties(boolean follow);
/**
* 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.
* @param follow boolean
* TODO: Model Documentation for
* ClassifierFacade.getProperties(follow)
* @return handleGetProperties(follow)
*/
public List getProperties(boolean follow)
{
// getProperties has no pre constraints
List returnValue = handleGetProperties(follow);
// getProperties has no post constraints
return returnValue;
}
/**
* Method to be implemented in descendants
* 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.
* @param follow
* @return List<AssociationEndFacade>
*/
protected abstract List<AssociationEndFacade> handleGetNavigableConnectingEnds(boolean follow);
/**
* 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.
* @param follow boolean
* Whether or not to follow the inheritance hierarchy when retrieving navicables.
* @return handleGetNavigableConnectingEnds(follow)
*/
public List<AssociationEndFacade> getNavigableConnectingEnds(boolean follow)
{
// getNavigableConnectingEnds has no pre constraints
List<AssociationEndFacade> returnValue = handleGetNavigableConnectingEnds(follow);
// getNavigableConnectingEnds has no post constraints
return returnValue;
}
// ------------- associations ------------------
private ClassifierFacade __getArray1r;
private boolean __getArray1rSet = false;
/**
* 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.
* @return (ClassifierFacade)handleGetArray()
*/
public final ClassifierFacade getArray()
{
ClassifierFacade getArray1r = this.__getArray1r;
if (!this.__getArray1rSet)
{
// nonArray has no pre constraints
Object result = handleGetArray();
MetafacadeBase shieldedResult = this.shieldedElement(result);
try
{
getArray1r = (ClassifierFacade)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getArray ClassifierFacade " + result + ": " + shieldedResult);
}
// nonArray has no post constraints
this.__getArray1r = getArray1r;
if (isMetafacadePropertyCachingEnabled())
{
this.__getArray1rSet = true;
}
}
return getArray1r;
}
/**
* UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
* @return Object
*/
protected abstract Object handleGetArray();
/**
* A Classifier is a classification of instances - it describes a set of instances that have
* features
* in common. Can specify a generalization hierarchy by referencing its general classifiers. It
* may be
* a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
* generalization hierarchy by referencing its general classifiers. Has the capability to own
* collaboration uses. These collaboration uses link a collaboration with the classifier to give
* a
* description of the workings of the classifier. Classifier is defined to be a kind of
* templateable
* element so that a classifier can be parameterized. It is also defined to be a kind of
* parameterable
* element so that a classifier can be a formal template parameter.
* @return (List<OperationFacade>)handleGetInstanceOperations()
*/
public final List<OperationFacade> getInstanceOperations()
{
List<OperationFacade> getInstanceOperations2r = null;
// classifierFacade has no pre constraints
List result = handleGetInstanceOperations();
List shieldedResult = this.shieldedElements(result);
try
{
getInstanceOperations2r = (List<OperationFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getInstanceOperations List<OperationFacade> " + result + ": " + shieldedResult);
}
// classifierFacade has no post constraints
return getInstanceOperations2r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return List
*/
protected abstract List handleGetInstanceOperations();
/**
* Gets the owner of this operation
* @return (List<OperationFacade>)handleGetOperations()
*/
public final List<OperationFacade> getOperations()
{
List<OperationFacade> getOperations3r = null;
// owner has no pre constraints
List result = handleGetOperations();
List shieldedResult = this.shieldedElements(result);
try
{
getOperations3r = (List<OperationFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getOperations List<OperationFacade> " + result + ": " + shieldedResult);
}
// owner has no post constraints
return getOperations3r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return List
*/
protected abstract List handleGetOperations();
/**
* A Classifier is a classification of instances - it describes a set of instances that have
* features
* in common. Can specify a generalization hierarchy by referencing its general classifiers. It
* may be
* a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
* generalization hierarchy by referencing its general classifiers. Has the capability to own
* collaboration uses. These collaboration uses link a collaboration with the classifier to give
* a
* description of the workings of the classifier. Classifier is defined to be a kind of
* templateable
* element so that a classifier can be parameterized. It is also defined to be a kind of
* parameterable
* element so that a classifier can be a formal template parameter.
* @return (List<OperationFacade>)handleGetStaticOperations()
*/
public final List<OperationFacade> getStaticOperations()
{
List<OperationFacade> getStaticOperations4r = null;
// classifierFacade has no pre constraints
List result = handleGetStaticOperations();
List shieldedResult = this.shieldedElements(result);
try
{
getStaticOperations4r = (List<OperationFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getStaticOperations List<OperationFacade> " + result + ": " + shieldedResult);
}
// classifierFacade has no post constraints
return getStaticOperations4r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return List
*/
protected abstract List handleGetStaticOperations();
/**
* A Classifier is a classification of instances - it describes a set of instances that have
* features
* in common. Can specify a generalization hierarchy by referencing its general classifiers. It
* may be
* a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
* generalization hierarchy by referencing its general classifiers. Has the capability to own
* collaboration uses. These collaboration uses link a collaboration with the classifier to give
* a
* description of the workings of the classifier. Classifier is defined to be a kind of
* templateable
* element so that a classifier can be parameterized. It is also defined to be a kind of
* parameterable
* element so that a classifier can be a formal template parameter.
* @return (Collection<ClassifierFacade>)handleGetAbstractions()
*/
public final Collection<ClassifierFacade> getAbstractions()
{
Collection<ClassifierFacade> getAbstractions5r = null;
// classifierFacade has no pre constraints
Collection result = handleGetAbstractions();
List shieldedResult = this.shieldedElements(result);
try
{
getAbstractions5r = (Collection<ClassifierFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getAbstractions Collection<ClassifierFacade> " + result + ": " + shieldedResult);
}
// classifierFacade has no post constraints
return getAbstractions5r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return Collection
*/
protected abstract Collection handleGetAbstractions();
/**
* Gets the classifier who is the owner of the attributes.
* @return (List<AttributeFacade>)handleGetAttributes()
*/
public final List<AttributeFacade> getAttributes()
{
List<AttributeFacade> getAttributes6r = null;
// owner has no pre constraints
List result = handleGetAttributes();
List shieldedResult = this.shieldedElements(result);
try
{
getAttributes6r = (List<AttributeFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getAttributes List<AttributeFacade> " + result + ": " + shieldedResult);
}
// owner has no post constraints
return getAttributes6r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return List
*/
protected abstract List handleGetAttributes();
/**
* A Classifier is a classification of instances - it describes a set of instances that have
* features
* in common. Can specify a generalization hierarchy by referencing its general classifiers. It
* may be
* a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
* generalization hierarchy by referencing its general classifiers. Has the capability to own
* collaboration uses. These collaboration uses link a collaboration with the classifier to give
* a
* description of the workings of the classifier. Classifier is defined to be a kind of
* templateable
* element so that a classifier can be parameterized. It is also defined to be a kind of
* parameterable
* element so that a classifier can be a formal template parameter.
* @return (Collection<AttributeFacade>)handleGetStaticAttributes()
*/
public final Collection<AttributeFacade> getStaticAttributes()
{
Collection<AttributeFacade> getStaticAttributes7r = null;
// classifierFacade has no pre constraints
Collection result = handleGetStaticAttributes();
List shieldedResult = this.shieldedElements(result);
try
{
getStaticAttributes7r = (Collection<AttributeFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getStaticAttributes Collection<AttributeFacade> " + result + ": " + shieldedResult);
}
// classifierFacade has no post constraints
return getStaticAttributes7r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return Collection
*/
protected abstract Collection handleGetStaticAttributes();
/**
* A Classifier is a classification of instances - it describes a set of instances that have
* features
* in common. Can specify a generalization hierarchy by referencing its general classifiers. It
* may be
* a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
* generalization hierarchy by referencing its general classifiers. Has the capability to own
* collaboration uses. These collaboration uses link a collaboration with the classifier to give
* a
* description of the workings of the classifier. Classifier is defined to be a kind of
* templateable
* element so that a classifier can be parameterized. It is also defined to be a kind of
* parameterable
* element so that a classifier can be a formal template parameter.
* @return (Collection<AssociationEndFacade>)handleGetNavigableConnectingEnds()
*/
public final Collection<AssociationEndFacade> getNavigableConnectingEnds()
{
Collection<AssociationEndFacade> getNavigableConnectingEnds8r = null;
// classifierFacade has no pre constraints
Collection result = handleGetNavigableConnectingEnds();
List shieldedResult = this.shieldedElements(result);
try
{
getNavigableConnectingEnds8r = (Collection<AssociationEndFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getNavigableConnectingEnds Collection<AssociationEndFacade> " + result + ": " + shieldedResult);
}
// classifierFacade has no post constraints
return getNavigableConnectingEnds8r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return Collection
*/
protected abstract Collection handleGetNavigableConnectingEnds();
/**
* A Classifier is a classification of instances - it describes a set of instances that have
* features
* in common. Can specify a generalization hierarchy by referencing its general classifiers. It
* may be
* a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
* generalization hierarchy by referencing its general classifiers. Has the capability to own
* collaboration uses. These collaboration uses link a collaboration with the classifier to give
* a
* description of the workings of the classifier. Classifier is defined to be a kind of
* templateable
* element so that a classifier can be parameterized. It is also defined to be a kind of
* parameterable
* element so that a classifier can be a formal template parameter.
* @return (List<AssociationEndFacade>)handleGetAssociationEnds()
*/
public final List<AssociationEndFacade> getAssociationEnds()
{
List<AssociationEndFacade> getAssociationEnds9r = null;
// classifierFacade has no pre constraints
List result = handleGetAssociationEnds();
List shieldedResult = this.shieldedElements(result);
try
{
getAssociationEnds9r = (List<AssociationEndFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getAssociationEnds List<AssociationEndFacade> " + result + ": " + shieldedResult);
}
// classifierFacade has no post constraints
return getAssociationEnds9r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return List
*/
protected abstract List handleGetAssociationEnds();
/**
* A Classifier is a classification of instances - it describes a set of instances that have
* features
* in common. Can specify a generalization hierarchy by referencing its general classifiers. It
* may be
* a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
* generalization hierarchy by referencing its general classifiers. Has the capability to own
* collaboration uses. These collaboration uses link a collaboration with the classifier to give
* a
* description of the workings of the classifier. Classifier is defined to be a kind of
* templateable
* element so that a classifier can be parameterized. It is also defined to be a kind of
* parameterable
* element so that a classifier can be a formal template parameter.
* @return (Collection<AttributeFacade>)handleGetInstanceAttributes()
*/
public final Collection<AttributeFacade> getInstanceAttributes()
{
Collection<AttributeFacade> getInstanceAttributes10r = null;
// classifierFacade has no pre constraints
Collection result = handleGetInstanceAttributes();
List shieldedResult = this.shieldedElements(result);
try
{
getInstanceAttributes10r = (Collection<AttributeFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getInstanceAttributes Collection<AttributeFacade> " + result + ": " + shieldedResult);
}
// classifierFacade has no post constraints
return getInstanceAttributes10r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return Collection
*/
protected abstract Collection handleGetInstanceAttributes();
private ClassifierFacade __getNonArray11r;
private boolean __getNonArray11rSet = false;
/**
* Gets the array type for this classifier. If this classifier already represents an array, it
* just returns itself.
* @return (ClassifierFacade)handleGetNonArray()
*/
public final ClassifierFacade getNonArray()
{
ClassifierFacade getNonArray11r = this.__getNonArray11r;
if (!this.__getNonArray11rSet)
{
// array has no pre constraints
Object result = handleGetNonArray();
MetafacadeBase shieldedResult = this.shieldedElement(result);
try
{
getNonArray11r = (ClassifierFacade)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getNonArray ClassifierFacade " + result + ": " + shieldedResult);
}
// array has no post constraints
this.__getNonArray11r = getNonArray11r;
if (isMetafacadePropertyCachingEnabled())
{
this.__getNonArray11rSet = true;
}
}
return getNonArray11r;
}
/**
* UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
* @return Object
*/
protected abstract Object handleGetNonArray();
/**
* Lists the classes associated to this one, there is no repitition of classes. The order of the
* elements is predictable.
* @return (Collection<ClassifierFacade>)handleGetAllAssociatedClasses()
*/
public final Collection<ClassifierFacade> getAllAssociatedClasses()
{
Collection<ClassifierFacade> getAllAssociatedClasses12r = null;
// associatedClasses has no pre constraints
Collection result = handleGetAllAssociatedClasses();
List shieldedResult = this.shieldedElements(result);
try
{
getAllAssociatedClasses12r = (Collection<ClassifierFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getAllAssociatedClasses Collection<ClassifierFacade> " + result + ": " + shieldedResult);
}
// associatedClasses has no post constraints
return getAllAssociatedClasses12r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return Collection
*/
protected abstract Collection handleGetAllAssociatedClasses();
/**
* 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.
* @return (Collection<ClassifierFacade>)handleGetAssociatedClasses()
*/
public final Collection<ClassifierFacade> getAssociatedClasses()
{
Collection<ClassifierFacade> getAssociatedClasses13r = null;
// allAssociatedClasses has no pre constraints
Collection result = handleGetAssociatedClasses();
List shieldedResult = this.shieldedElements(result);
try
{
getAssociatedClasses13r = (Collection<ClassifierFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getAssociatedClasses Collection<ClassifierFacade> " + result + ": " + shieldedResult);
}
// allAssociatedClasses has no post constraints
return getAssociatedClasses13r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return Collection
*/
protected abstract Collection handleGetAssociatedClasses();
private Collection<ClassifierFacade> __getInterfaceAbstractions14r;
private boolean __getInterfaceAbstractions14rSet = false;
/**
* A Classifier is a classification of instances - it describes a set of instances that have
* features
* in common. Can specify a generalization hierarchy by referencing its general classifiers. It
* may be
* a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
* generalization hierarchy by referencing its general classifiers. Has the capability to own
* collaboration uses. These collaboration uses link a collaboration with the classifier to give
* a
* description of the workings of the classifier. Classifier is defined to be a kind of
* templateable
* element so that a classifier can be parameterized. It is also defined to be a kind of
* parameterable
* element so that a classifier can be a formal template parameter.
* @return (Collection<ClassifierFacade>)handleGetInterfaceAbstractions()
*/
public final Collection<ClassifierFacade> getInterfaceAbstractions()
{
Collection<ClassifierFacade> getInterfaceAbstractions14r = this.__getInterfaceAbstractions14r;
if (!this.__getInterfaceAbstractions14rSet)
{
// classifierFacade has no pre constraints
Collection result = handleGetInterfaceAbstractions();
List shieldedResult = this.shieldedElements(result);
try
{
getInterfaceAbstractions14r = (Collection<ClassifierFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getInterfaceAbstractions Collection<ClassifierFacade> " + result + ": " + shieldedResult);
}
// classifierFacade has no post constraints
this.__getInterfaceAbstractions14r = getInterfaceAbstractions14r;
if (isMetafacadePropertyCachingEnabled())
{
this.__getInterfaceAbstractions14rSet = true;
}
}
return getInterfaceAbstractions14r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return Collection
*/
protected abstract Collection handleGetInterfaceAbstractions();
private ClassifierFacade __getSuperClass15r;
private boolean __getSuperClass15rSet = false;
/**
* A Classifier is a classification of instances - it describes a set of instances that have
* features
* in common. Can specify a generalization hierarchy by referencing its general classifiers. It
* may be
* a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
* generalization hierarchy by referencing its general classifiers. Has the capability to own
* collaboration uses. These collaboration uses link a collaboration with the classifier to give
* a
* description of the workings of the classifier. Classifier is defined to be a kind of
* templateable
* element so that a classifier can be parameterized. It is also defined to be a kind of
* parameterable
* element so that a classifier can be a formal template parameter.
* @return (ClassifierFacade)handleGetSuperClass()
*/
public final ClassifierFacade getSuperClass()
{
ClassifierFacade getSuperClass15r = this.__getSuperClass15r;
if (!this.__getSuperClass15rSet)
{
// classifierFacade has no pre constraints
Object result = handleGetSuperClass();
MetafacadeBase shieldedResult = this.shieldedElement(result);
try
{
getSuperClass15r = (ClassifierFacade)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getSuperClass ClassifierFacade " + result + ": " + shieldedResult);
}
// classifierFacade has no post constraints
this.__getSuperClass15r = getSuperClass15r;
if (isMetafacadePropertyCachingEnabled())
{
this.__getSuperClass15rSet = true;
}
}
return getSuperClass15r;
}
/**
* UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
* @return Object
*/
protected abstract Object handleGetSuperClass();
private Collection<OperationFacade> __getImplementationOperations16r;
private boolean __getImplementationOperations16rSet = false;
/**
* A Classifier is a classification of instances - it describes a set of instances that have
* features
* in common. Can specify a generalization hierarchy by referencing its general classifiers. It
* may be
* a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
* generalization hierarchy by referencing its general classifiers. Has the capability to own
* collaboration uses. These collaboration uses link a collaboration with the classifier to give
* a
* description of the workings of the classifier. Classifier is defined to be a kind of
* templateable
* element so that a classifier can be parameterized. It is also defined to be a kind of
* parameterable
* element so that a classifier can be a formal template parameter.
* @return (Collection<OperationFacade>)handleGetImplementationOperations()
*/
public final Collection<OperationFacade> getImplementationOperations()
{
Collection<OperationFacade> getImplementationOperations16r = this.__getImplementationOperations16r;
if (!this.__getImplementationOperations16rSet)
{
// classifierFacade has no pre constraints
Collection result = handleGetImplementationOperations();
List shieldedResult = this.shieldedElements(result);
try
{
getImplementationOperations16r = (Collection<OperationFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
ClassifierFacadeLogic.logger.warn("incorrect metafacade cast for ClassifierFacadeLogic.getImplementationOperations Collection<OperationFacade> " + result + ": " + shieldedResult);
}
// classifierFacade has no post constraints
this.__getImplementationOperations16r = getImplementationOperations16r;
if (isMetafacadePropertyCachingEnabled())
{
this.__getImplementationOperations16rSet = true;
}
}
return getImplementationOperations16r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return Collection
*/
protected abstract Collection handleGetImplementationOperations();
/**
* <p><b>Constraint:</b> org::andromda::metafacades::uml::ClassifierFacade::classifier must have a name</p>
* <p><b>Error:</b> Each classifier must have a non-empty name.</p>
* <p><b>OCL:</b> context ClassifierFacade inv: name->notEmpty()</p>
* <p><b>Constraint:</b> org::andromda::metafacades::uml::ClassifierFacade::attribute names must be unique</p>
* <p><b>Error:</b> Each attribute on an element must have a unique name.</p>
* <p><b>OCL:</b> context ClassifierFacade
inv : attributes -> isUnique(name)</p>
* <p><b>Constraint:</b> org::andromda::metafacades::uml::ClassifierFacade::association end names must be unique</p>
* <p><b>Error:</b> The name of each navigable connecting association end must be unique.</p>
* <p><b>OCL:</b> context ClassifierFacade
inv : navigableConnectingEnds -> isUnique(name)</p>
* <p><b>Constraint:</b> org::andromda::metafacades::uml::ClassifierFacade::source dependencies must be unique</p>
* <p><b>Error:</b> Each dependency going out a of an element must have a unique name.</p>
* <p><b>OCL:</b> context ClassifierFacade
inv : sourceDependencies -> isUnique(name)</p>
* @param validationMessages Collection<ModelValidationMessage>
* @see GeneralizableElementFacadeLogicImpl#validateInvariants(Collection validationMessages)
*/
@Override
public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
{
super.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::metafacades::uml::ClassifierFacade::classifier must have a name",
"Each classifier must have a non-empty name."));
}
}
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::metafacades::uml::ClassifierFacade::classifier must have a name' ON "
+ this.THIS().toString() + ": " + th.getMessage(), th);
}
try
{
final Object contextElement = this.THIS();
boolean constraintValid = OCLResultEnsurer.ensure(OCLCollections.isUnique(OCLIntrospector.invoke(contextElement,"attributes"),new Transformer(){public Object transform(Object object){return OCLIntrospector.invoke(object,"name");}}));
if (!constraintValid)
{
validationMessages.add(
new ModelValidationMessage(
(MetafacadeBase)contextElement ,
"org::andromda::metafacades::uml::ClassifierFacade::attribute names must be unique",
"Each attribute on an element must have a unique name."));
}
}
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::metafacades::uml::ClassifierFacade::attribute names must be unique' ON "
+ this.THIS().toString() + ": " + th.getMessage(), th);
}
try
{
final Object contextElement = this.THIS();
boolean constraintValid = OCLResultEnsurer.ensure(OCLCollections.isUnique(OCLIntrospector.invoke(contextElement,"navigableConnectingEnds"),new Transformer(){public Object transform(Object object){return OCLIntrospector.invoke(object,"name");}}));
if (!constraintValid)
{
validationMessages.add(
new ModelValidationMessage(
(MetafacadeBase)contextElement ,
"org::andromda::metafacades::uml::ClassifierFacade::association end names must be unique",
"The name of each navigable connecting association end must be unique."));
}
}
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::metafacades::uml::ClassifierFacade::association end names must be unique' ON "
+ this.THIS().toString() + ": " + th.getMessage(), th);
}
try
{
final Object contextElement = this.THIS();
boolean constraintValid = OCLResultEnsurer.ensure(OCLCollections.isUnique(OCLIntrospector.invoke(contextElement,"sourceDependencies"),new Transformer(){public Object transform(Object object){return OCLIntrospector.invoke(object,"name");}}));
if (!constraintValid)
{
validationMessages.add(
new ModelValidationMessage(
(MetafacadeBase)contextElement ,
"org::andromda::metafacades::uml::ClassifierFacade::source dependencies must be unique",
"Each dependency going out a of an element must have a unique name."));
}
}
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::metafacades::uml::ClassifierFacade::source dependencies must be unique' ON "
+ this.THIS().toString() + ": " + th.getMessage(), th);
}
}
}