AttributeFacadeLogic.java
// license-header java merge-point
//
// Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
//
package org.andromda.metafacades.uml14;
import java.util.Collection;
import org.andromda.core.metafacade.MetafacadeBase;
import org.andromda.core.metafacade.ModelValidationMessage;
import org.andromda.metafacades.uml.AttributeFacade;
import org.andromda.metafacades.uml.ClassifierFacade;
import org.andromda.metafacades.uml.EnumerationFacade;
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.log4j.Logger;
import org.omg.uml.foundation.core.Attribute;
/**
* Represents an attribute on a classifier. UML2 maps both Attributes and AssociationEnds to
* Property. A property is a structural feature of a classifier that characterizes instances of the
* classifier. A property related by ownedAttribute to a classifier (other than an association)
* represents an attribute and might also represent an association end. It relates an instance of
* the class to a value or set of values of the type of the attribute. A property represents a set
* of instances that are owned by a containing classifier instance. Property represents a declared
* state of one or more instances in terms of a named relationship to a value or values. When a
* property is an attribute of a classifier, the value or values are related to the instance of the
* classifier by being held in slots of the instance. The range of valid values represented by the
* property can be controlled by setting the property's type.
* MetafacadeLogic for AttributeFacade
*
* @see AttributeFacade
*/
public abstract class AttributeFacadeLogic
extends ModelElementFacadeLogicImpl
implements AttributeFacade
{
/**
* The underlying UML object
* @see Attribute
*/
protected Attribute metaObject;
/** Create Metafacade implementation instance using the MetafacadeFactory from the context
* @param metaObjectIn
* @param context
*/
protected AttributeFacadeLogic(Attribute metaObjectIn, String context)
{
super(metaObjectIn, getContext(context));
this.metaObject = metaObjectIn;
}
/**
* The logger instance.
*/
private static final Logger logger = Logger.getLogger(AttributeFacadeLogic.class);
/**
* Gets the context for this metafacade logic instance.
* @param context String. Set to AttributeFacade if null
* @return context String
*/
private static String getContext(String context)
{
if (context == null)
{
context = "org.andromda.metafacades.uml.AttributeFacade";
}
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 AttributeFacade
*/
public boolean isAttributeFacadeMetaType()
{
return true;
}
// --------------- attributes ---------------------
/**
* @see AttributeFacade#getGetterName()
* @return String
*/
protected abstract String handleGetGetterName();
private String __getterName1a;
private boolean __getterName1aSet = false;
/**
* The name of the accessor operation that would retrieve this attribute's value.
* @return (String)handleGetGetterName()
*/
public final String getGetterName()
{
String getterName1a = this.__getterName1a;
if (!this.__getterName1aSet)
{
// getterName has no pre constraints
getterName1a = handleGetGetterName();
// getterName has no post constraints
this.__getterName1a = getterName1a;
if (isMetafacadePropertyCachingEnabled())
{
this.__getterName1aSet = true;
}
}
return getterName1a;
}
/**
* @see AttributeFacade#getSetterName()
* @return String
*/
protected abstract String handleGetSetterName();
private String __setterName2a;
private boolean __setterName2aSet = false;
/**
* The name of the mutator operation that would retrieve this attribute's value.
* @return (String)handleGetSetterName()
*/
public final String getSetterName()
{
String setterName2a = this.__setterName2a;
if (!this.__setterName2aSet)
{
// setterName has no pre constraints
setterName2a = handleGetSetterName();
// setterName has no post constraints
this.__setterName2a = setterName2a;
if (isMetafacadePropertyCachingEnabled())
{
this.__setterName2aSet = true;
}
}
return setterName2a;
}
/**
* @see AttributeFacade#isReadOnly()
* @return boolean
*/
protected abstract boolean handleIsReadOnly();
private boolean __readOnly3a;
private boolean __readOnly3aSet = false;
/**
* Whether or not this attribute can be modified.
* @return (boolean)handleIsReadOnly()
*/
public final boolean isReadOnly()
{
boolean readOnly3a = this.__readOnly3a;
if (!this.__readOnly3aSet)
{
// readOnly has no pre constraints
readOnly3a = handleIsReadOnly();
// readOnly has no post constraints
this.__readOnly3a = readOnly3a;
if (isMetafacadePropertyCachingEnabled())
{
this.__readOnly3aSet = true;
}
}
return readOnly3a;
}
/**
* @see AttributeFacade#getDefaultValue()
* @return String
*/
protected abstract String handleGetDefaultValue();
private String __defaultValue4a;
private boolean __defaultValue4aSet = false;
/**
* The default value of the attribute. This is the value given if no value is defined.
* @return (String)handleGetDefaultValue()
*/
public final String getDefaultValue()
{
String defaultValue4a = this.__defaultValue4a;
if (!this.__defaultValue4aSet)
{
// defaultValue has no pre constraints
defaultValue4a = handleGetDefaultValue();
// defaultValue has no post constraints
this.__defaultValue4a = defaultValue4a;
if (isMetafacadePropertyCachingEnabled())
{
this.__defaultValue4aSet = true;
}
}
return defaultValue4a;
}
/**
* @see AttributeFacade#isStatic()
* @return boolean
*/
protected abstract boolean handleIsStatic();
private boolean __static5a;
private boolean __static5aSet = false;
/**
* Indicates if this attribute is 'static', meaning it has a classifier scope.
* @return (boolean)handleIsStatic()
*/
public final boolean isStatic()
{
boolean static5a = this.__static5a;
if (!this.__static5aSet)
{
// static has no pre constraints
static5a = handleIsStatic();
// static has no post constraints
this.__static5a = static5a;
if (isMetafacadePropertyCachingEnabled())
{
this.__static5aSet = true;
}
}
return static5a;
}
/**
* @see AttributeFacade#isRequired()
* @return boolean
*/
protected abstract boolean handleIsRequired();
private boolean __required6a;
private boolean __required6aSet = false;
/**
* Whether or not the multiplicity of this attribute is 1.
* @return (boolean)handleIsRequired()
*/
public final boolean isRequired()
{
boolean required6a = this.__required6a;
if (!this.__required6aSet)
{
// required has no pre constraints
required6a = handleIsRequired();
// required has no post constraints
this.__required6a = required6a;
if (isMetafacadePropertyCachingEnabled())
{
this.__required6aSet = true;
}
}
return required6a;
}
/**
* @see AttributeFacade#isMany()
* @return boolean
*/
protected abstract boolean handleIsMany();
private boolean __many7a;
private boolean __many7aSet = false;
/**
* Whether or not this attribute has a multiplicity greater than 1.
* @return (boolean)handleIsMany()
*/
public final boolean isMany()
{
boolean many7a = this.__many7a;
if (!this.__many7aSet)
{
// many has no pre constraints
many7a = handleIsMany();
// many has no post constraints
this.__many7a = many7a;
if (isMetafacadePropertyCachingEnabled())
{
this.__many7aSet = true;
}
}
return many7a;
}
/**
* @see AttributeFacade#isChangeable()
* @return boolean
*/
protected abstract boolean handleIsChangeable();
private boolean __changeable8a;
private boolean __changeable8aSet = false;
/**
* True if this attribute can be modified.
* @return (boolean)handleIsChangeable()
*/
public final boolean isChangeable()
{
boolean changeable8a = this.__changeable8a;
if (!this.__changeable8aSet)
{
// changeable has no pre constraints
changeable8a = handleIsChangeable();
// changeable has no post constraints
this.__changeable8a = changeable8a;
if (isMetafacadePropertyCachingEnabled())
{
this.__changeable8aSet = true;
}
}
return changeable8a;
}
/**
* @see AttributeFacade#isAddOnly()
* @return boolean
*/
protected abstract boolean handleIsAddOnly();
private boolean __addOnly9a;
private boolean __addOnly9aSet = false;
/**
* True if this attribute can only be set.
* @return (boolean)handleIsAddOnly()
*/
public final boolean isAddOnly()
{
boolean addOnly9a = this.__addOnly9a;
if (!this.__addOnly9aSet)
{
// addOnly has no pre constraints
addOnly9a = handleIsAddOnly();
// addOnly has no post constraints
this.__addOnly9a = addOnly9a;
if (isMetafacadePropertyCachingEnabled())
{
this.__addOnly9aSet = true;
}
}
return addOnly9a;
}
/**
* @see AttributeFacade#isEnumerationLiteral()
* @return boolean
*/
protected abstract boolean handleIsEnumerationLiteral();
private boolean __enumerationLiteral10a;
private boolean __enumerationLiteral10aSet = false;
/**
* True if this attribute is owned by an enumeration.
* @return (boolean)handleIsEnumerationLiteral()
*/
public final boolean isEnumerationLiteral()
{
boolean enumerationLiteral10a = this.__enumerationLiteral10a;
if (!this.__enumerationLiteral10aSet)
{
// enumerationLiteral has no pre constraints
enumerationLiteral10a = handleIsEnumerationLiteral();
// enumerationLiteral has no post constraints
this.__enumerationLiteral10a = enumerationLiteral10a;
if (isMetafacadePropertyCachingEnabled())
{
this.__enumerationLiteral10aSet = true;
}
}
return enumerationLiteral10a;
}
/**
* @see AttributeFacade#getEnumerationValue()
* @return String
*/
protected abstract String handleGetEnumerationValue();
private String __enumerationValue11a;
private boolean __enumerationValue11aSet = false;
/**
* The value for this attribute if it is an enumeration literal, null otherwise. The default
* value is returned as a String if it has been specified, if it's not specified this
* attribute's name is assumed.
* @return (String)handleGetEnumerationValue()
*/
public final String getEnumerationValue()
{
String enumerationValue11a = this.__enumerationValue11a;
if (!this.__enumerationValue11aSet)
{
// enumerationValue has no pre constraints
enumerationValue11a = handleGetEnumerationValue();
// enumerationValue has no post constraints
this.__enumerationValue11a = enumerationValue11a;
if (isMetafacadePropertyCachingEnabled())
{
this.__enumerationValue11aSet = true;
}
}
return enumerationValue11a;
}
/**
* @see AttributeFacade#getGetterSetterTypeName()
* @return String
*/
protected abstract String handleGetGetterSetterTypeName();
private String __getterSetterTypeName12a;
private boolean __getterSetterTypeName12aSet = false;
/**
* The name of the type that is returned on the accessor and mutator operations, determined in
* part by the multiplicity.
* @return (String)handleGetGetterSetterTypeName()
*/
public final String getGetterSetterTypeName()
{
String getterSetterTypeName12a = this.__getterSetterTypeName12a;
if (!this.__getterSetterTypeName12aSet)
{
// getterSetterTypeName has no pre constraints
getterSetterTypeName12a = handleGetGetterSetterTypeName();
// getterSetterTypeName has no post constraints
this.__getterSetterTypeName12a = getterSetterTypeName12a;
if (isMetafacadePropertyCachingEnabled())
{
this.__getterSetterTypeName12aSet = true;
}
}
return getterSetterTypeName12a;
}
/**
* @see AttributeFacade#isOrdered()
* @return boolean
*/
protected abstract boolean handleIsOrdered();
private boolean __ordered13a;
private boolean __ordered13aSet = false;
/**
* Indicates whether or not the attributes are ordered (if multiplicity is greater than 1).
* @return (boolean)handleIsOrdered()
*/
public final boolean isOrdered()
{
boolean ordered13a = this.__ordered13a;
if (!this.__ordered13aSet)
{
// ordered has no pre constraints
ordered13a = handleIsOrdered();
// ordered has no post constraints
this.__ordered13a = ordered13a;
if (isMetafacadePropertyCachingEnabled())
{
this.__ordered13aSet = true;
}
}
return ordered13a;
}
/**
* @see AttributeFacade#isDefaultValuePresent()
* @return boolean
*/
protected abstract boolean handleIsDefaultValuePresent();
private boolean __defaultValuePresent14a;
private boolean __defaultValuePresent14aSet = false;
/**
* Indicates if the default value is present.
* @return (boolean)handleIsDefaultValuePresent()
*/
public final boolean isDefaultValuePresent()
{
boolean defaultValuePresent14a = this.__defaultValuePresent14a;
if (!this.__defaultValuePresent14aSet)
{
// defaultValuePresent has no pre constraints
defaultValuePresent14a = handleIsDefaultValuePresent();
// defaultValuePresent has no post constraints
this.__defaultValuePresent14a = defaultValuePresent14a;
if (isMetafacadePropertyCachingEnabled())
{
this.__defaultValuePresent14aSet = true;
}
}
return defaultValuePresent14a;
}
/**
* @see AttributeFacade#getUpper()
* @return int
*/
protected abstract int handleGetUpper();
private int __upper15a;
private boolean __upper15aSet = false;
/**
* the upper value for the multiplicity (will be -1 for *)
* -only applicable for UML2
* @return (int)handleGetUpper()
*/
public final int getUpper()
{
int upper15a = this.__upper15a;
if (!this.__upper15aSet)
{
// upper has no pre constraints
upper15a = handleGetUpper();
// upper has no post constraints
this.__upper15a = upper15a;
if (isMetafacadePropertyCachingEnabled())
{
this.__upper15aSet = true;
}
}
return upper15a;
}
/**
* @see AttributeFacade#getLower()
* @return int
*/
protected abstract int handleGetLower();
private int __lower16a;
private boolean __lower16aSet = false;
/**
* the lower value for the multiplicity
* -only applicable for UML2
* @return (int)handleGetLower()
*/
public final int getLower()
{
int lower16a = this.__lower16a;
if (!this.__lower16aSet)
{
// lower has no pre constraints
lower16a = handleGetLower();
// lower has no post constraints
this.__lower16a = lower16a;
if (isMetafacadePropertyCachingEnabled())
{
this.__lower16aSet = true;
}
}
return lower16a;
}
/**
* @see AttributeFacade#isEnumerationMember()
* @return boolean
*/
protected abstract boolean handleIsEnumerationMember();
private boolean __enumerationMember17a;
private boolean __enumerationMember17aSet = false;
/**
* True if this attribute is owned by an enumeration but is defined as a member variable (NOT a
* literal).
* @return (boolean)handleIsEnumerationMember()
*/
public final boolean isEnumerationMember()
{
boolean enumerationMember17a = this.__enumerationMember17a;
if (!this.__enumerationMember17aSet)
{
// enumerationMember has no pre constraints
enumerationMember17a = handleIsEnumerationMember();
// enumerationMember has no post constraints
this.__enumerationMember17a = enumerationMember17a;
if (isMetafacadePropertyCachingEnabled())
{
this.__enumerationMember17aSet = true;
}
}
return enumerationMember17a;
}
/**
* @see AttributeFacade#getEnumerationLiteralParameters()
* @return String
*/
protected abstract String handleGetEnumerationLiteralParameters();
private String __enumerationLiteralParameters18a;
private boolean __enumerationLiteralParameters18aSet = false;
/**
* Returns the enumeration literal parameters defined by tagged value as a comma separated list.
* @return (String)handleGetEnumerationLiteralParameters()
*/
public final String getEnumerationLiteralParameters()
{
String enumerationLiteralParameters18a = this.__enumerationLiteralParameters18a;
if (!this.__enumerationLiteralParameters18aSet)
{
// enumerationLiteralParameters has no pre constraints
enumerationLiteralParameters18a = handleGetEnumerationLiteralParameters();
// enumerationLiteralParameters has no post constraints
this.__enumerationLiteralParameters18a = enumerationLiteralParameters18a;
if (isMetafacadePropertyCachingEnabled())
{
this.__enumerationLiteralParameters18aSet = true;
}
}
return enumerationLiteralParameters18a;
}
/**
* @see AttributeFacade#isEnumerationLiteralParametersExist()
* @return boolean
*/
protected abstract boolean handleIsEnumerationLiteralParametersExist();
private boolean __enumerationLiteralParametersExist19a;
private boolean __enumerationLiteralParametersExist19aSet = false;
/**
* Returns true if enumeration literal parameters exist (defined by tagged value) for the
* literal.
* @return (boolean)handleIsEnumerationLiteralParametersExist()
*/
public final boolean isEnumerationLiteralParametersExist()
{
boolean enumerationLiteralParametersExist19a = this.__enumerationLiteralParametersExist19a;
if (!this.__enumerationLiteralParametersExist19aSet)
{
// enumerationLiteralParametersExist has no pre constraints
enumerationLiteralParametersExist19a = handleIsEnumerationLiteralParametersExist();
// enumerationLiteralParametersExist has no post constraints
this.__enumerationLiteralParametersExist19a = enumerationLiteralParametersExist19a;
if (isMetafacadePropertyCachingEnabled())
{
this.__enumerationLiteralParametersExist19aSet = true;
}
}
return enumerationLiteralParametersExist19a;
}
/**
* @see AttributeFacade#isUnique()
* @return boolean
*/
protected abstract boolean handleIsUnique();
private boolean __unique20a;
private boolean __unique20aSet = false;
/**
* If the attribute is unique within the Collection type. UML2 only. UML14 always returns false.
* Unique+Ordered determines the implementation Collection type. Default=false.
* @return (boolean)handleIsUnique()
*/
public final boolean isUnique()
{
boolean unique20a = this.__unique20a;
if (!this.__unique20aSet)
{
// unique has no pre constraints
unique20a = handleIsUnique();
// unique has no post constraints
this.__unique20a = unique20a;
if (isMetafacadePropertyCachingEnabled())
{
this.__unique20aSet = true;
}
}
return unique20a;
}
/**
* @see AttributeFacade#isLeaf()
* @return boolean
*/
protected abstract boolean handleIsLeaf();
private boolean __leaf21a;
private boolean __leaf21aSet = false;
/**
* IsLeaf property in the operation. If true, operation is final, cannot be extended or
* implemented by a descendant.
* @return (boolean)handleIsLeaf()
*/
public final boolean isLeaf()
{
boolean leaf21a = this.__leaf21a;
if (!this.__leaf21aSet)
{
// leaf has no pre constraints
leaf21a = handleIsLeaf();
// leaf has no post constraints
this.__leaf21a = leaf21a;
if (isMetafacadePropertyCachingEnabled())
{
this.__leaf21aSet = true;
}
}
return leaf21a;
}
/**
* @see AttributeFacade#isDerived()
* @return boolean
*/
protected abstract boolean handleIsDerived();
private boolean __derived22a;
private boolean __derived22aSet = false;
/**
* If the attribute is derived (its value is computed). UML2 only. UML14 always returns false.
* Default=false.
* @return (boolean)handleIsDerived()
*/
public final boolean isDerived()
{
boolean derived22a = this.__derived22a;
if (!this.__derived22aSet)
{
// derived has no pre constraints
derived22a = handleIsDerived();
// derived has no post constraints
this.__derived22a = derived22a;
if (isMetafacadePropertyCachingEnabled())
{
this.__derived22aSet = true;
}
}
return derived22a;
}
// ---------------- business methods ----------------------
/**
* Method to be implemented in descendants
* Searches the given feature for the specified tag.
* If the follow boolean is set to true then the search will continue from the class attribute
* to the class itself and then up the class hierarchy.
* @param name
* @param follow
* @return Object
*/
protected abstract Object handleFindTaggedValue(String name, boolean follow);
/**
* Searches the given feature for the specified tag.
* If the follow boolean is set to true then the search will continue from the class attribute
* to the class itself and then up the class hierarchy.
* @param name String
* The name of the tagged value to find.
* @param follow boolean
* If true search should 'follow' the inheritance hierarchy, false otherwise.
* @return handleFindTaggedValue(name, follow)
*/
public Object findTaggedValue(String name, boolean follow)
{
// findTaggedValue has no pre constraints
Object returnValue = handleFindTaggedValue(name, follow);
// findTaggedValue has no post constraints
return returnValue;
}
// ------------- associations ------------------
/**
* Represents an attribute on a classifier. UML2 maps both Attributes and AssociationEnds to
* Property.
* A property is a structural feature of a classifier that characterizes instances of the
* classifier. A
* property related by ownedAttribute to a classifier (other than an association) represents an
* attribute and might also represent an association end. It relates an instance of the class to
* a
* value or set of values of the type of the attribute. A property represents a set of instances
* that
* are owned by a containing classifier instance. Property represents a declared state of one or
* more
* instances in terms of a named relationship to a value or values. When a property is an
* attribute of
* a classifier, the value or values are related to the instance of the classifier by being held
* in
* slots of the instance. The range of valid values represented by the property can be
* controlled by
* setting the property's type.
* @return (ClassifierFacade)handleGetType()
*/
public final ClassifierFacade getType()
{
ClassifierFacade getType1r = null;
// attributeFacade has no pre constraints
Object result = handleGetType();
MetafacadeBase shieldedResult = this.shieldedElement(result);
try
{
getType1r = (ClassifierFacade)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
AttributeFacadeLogic.logger.warn("incorrect metafacade cast for AttributeFacadeLogic.getType ClassifierFacade " + result + ": " + shieldedResult);
}
// attributeFacade has no post constraints
return getType1r;
}
/**
* UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
* @return Object
*/
protected abstract Object handleGetType();
/**
* This enumeration's literals.
* @return (EnumerationFacade)handleGetEnumeration()
*/
public final EnumerationFacade getEnumeration()
{
EnumerationFacade getEnumeration2r = null;
// literals has no pre constraints
Object result = handleGetEnumeration();
MetafacadeBase shieldedResult = this.shieldedElement(result);
try
{
getEnumeration2r = (EnumerationFacade)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
AttributeFacadeLogic.logger.warn("incorrect metafacade cast for AttributeFacadeLogic.getEnumeration EnumerationFacade " + result + ": " + shieldedResult);
}
// literals has no post constraints
return getEnumeration2r;
}
/**
* UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
* @return Object
*/
protected abstract Object handleGetEnumeration();
/**
* Gets the attributes that belong to the classifier.
* @return (ClassifierFacade)handleGetOwner()
*/
public final ClassifierFacade getOwner()
{
ClassifierFacade getOwner3r = null;
// attributes has no pre constraints
Object result = handleGetOwner();
MetafacadeBase shieldedResult = this.shieldedElement(result);
try
{
getOwner3r = (ClassifierFacade)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
AttributeFacadeLogic.logger.warn("incorrect metafacade cast for AttributeFacadeLogic.getOwner ClassifierFacade " + result + ": " + shieldedResult);
}
// attributes has no post constraints
return getOwner3r;
}
/**
* UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
* @return Object
*/
protected abstract Object handleGetOwner();
/**
* <p><b>Constraint:</b> org::andromda::metafacades::uml::AttributeFacade::attribute needs a type</p>
* <p><b>Error:</b> Each attribute needs a type, you cannot leave the type unspecified.</p>
* <p><b>OCL:</b> context AttributeFacade inv: type.name->notEmpty()</p>
* <p><b>Constraint:</b> org::andromda::metafacades::uml::AttributeFacade::attribute must have a name</p>
* <p><b>Error:</b> Each attribute must have a non-empty name.</p>
* <p><b>OCL:</b> context AttributeFacade inv: name -> notEmpty()</p>
* <p><b>Constraint:</b> org::andromda::metafacades::uml::AttributeFacade::primitive attribute must be required</p>
* <p><b>Error:</b> Primitive attributes must have a multiplicity lower bound > 0 (must be required). Use a wrapped type, or change the multiplicity.</p>
* <p><b>OCL:</b> context AttributeFacade inv: type.primitive implies (lower > 0)</p>
* <p><b>Constraint:</b> org::andromda::metafacades::uml::AttributeFacade::primitive attribute cannot be used in Collection</p>
* <p><b>Error:</b> Primitive attributes cannot be used in Collections (multiplicity > 1). Use the wrapped type instead.</p>
* <p><b>OCL:</b> context AttributeFacade inv: type.primitive implies (many = false)</p>
* <p><b>Constraint:</b> org::andromda::metafacades::uml::AttributeFacade::wrapped primitive attribute should not be required</p>
* <p><b>Error:</b> Wrapped primitive attributes must have a multiplicity lower bound = 0 (must be optional). Use the unwrapped type, or change the multiplicity.</p>
* <p><b>OCL:</b> context AttributeFacade inv: type.wrappedPrimitive and many = false implies (lower = 0)</p>
* @param validationMessages Collection<ModelValidationMessage>
* @see ModelElementFacadeLogicImpl#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,"type.name")));
if (!constraintValid)
{
validationMessages.add(
new ModelValidationMessage(
(MetafacadeBase)contextElement ,
"org::andromda::metafacades::uml::AttributeFacade::attribute needs a type",
"Each attribute needs a type, you cannot leave the type unspecified."));
}
}
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::AttributeFacade::attribute needs a type' ON "
+ this.THIS().toString() + ": " + th.getMessage(), th);
}
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::AttributeFacade::attribute must have a name",
"Each attribute 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::AttributeFacade::attribute must have a name' ON "
+ this.THIS().toString() + ": " + th.getMessage(), th);
}
try
{
final Object contextElement = this.THIS();
boolean constraintValid = OCLResultEnsurer.ensure((Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"type.primitive"))).booleanValue()?(OCLExpressions.greater(OCLIntrospector.invoke(contextElement,"lower"),0)):true));
if (!constraintValid)
{
validationMessages.add(
new ModelValidationMessage(
(MetafacadeBase)contextElement ,
"org::andromda::metafacades::uml::AttributeFacade::primitive attribute must be required",
"Primitive attributes must have a multiplicity lower bound > 0 (must be required). Use a wrapped type, or change the multiplicity."));
}
}
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::AttributeFacade::primitive attribute must be required' ON "
+ this.THIS().toString() + ": " + th.getMessage(), th);
}
try
{
final Object contextElement = this.THIS();
boolean constraintValid = OCLResultEnsurer.ensure((Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"type.primitive"))).booleanValue()?(OCLExpressions.equal(OCLIntrospector.invoke(contextElement,"many"),false)):true));
if (!constraintValid)
{
validationMessages.add(
new ModelValidationMessage(
(MetafacadeBase)contextElement ,
"org::andromda::metafacades::uml::AttributeFacade::primitive attribute cannot be used in Collection",
"Primitive attributes cannot be used in Collections (multiplicity > 1). Use the wrapped type instead."));
}
}
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::AttributeFacade::primitive attribute cannot be used in Collection' ON "
+ this.THIS().toString() + ": " + th.getMessage(), th);
}
try
{
final Object contextElement = this.THIS();
boolean constraintValid = OCLResultEnsurer.ensure((Boolean.valueOf(String.valueOf(Boolean.valueOf(String.valueOf(OCLIntrospector.invoke(contextElement,"type.wrappedPrimitive"))).booleanValue()&&OCLExpressions.equal(OCLIntrospector.invoke(contextElement,"many"),false))).booleanValue()?(OCLExpressions.equal(OCLIntrospector.invoke(contextElement,"lower"),0)):true));
if (!constraintValid)
{
validationMessages.add(
new ModelValidationMessage(
(MetafacadeBase)contextElement ,
"org::andromda::metafacades::uml::AttributeFacade::wrapped primitive attribute should not be required",
"Wrapped primitive attributes must have a multiplicity lower bound = 0 (must be optional). Use the unwrapped type, or change the multiplicity."));
}
}
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::AttributeFacade::wrapped primitive attribute should not be required' ON "
+ this.THIS().toString() + ": " + th.getMessage(), th);
}
}
}