OperationFacadeLogic.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 java.util.List;
import org.andromda.core.metafacade.MetafacadeBase;
import org.andromda.core.metafacade.ModelValidationMessage;
import org.andromda.metafacades.uml.ClassifierFacade;
import org.andromda.metafacades.uml.ConstraintFacade;
import org.andromda.metafacades.uml.ModelElementFacade;
import org.andromda.metafacades.uml.OperationFacade;
import org.andromda.metafacades.uml.ParameterFacade;
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.Operation;
/**
* A behavioral feature of a classifier that specifies the name, type, parameters, and constraints
* for invoking an associated behavior. May invoke both the execution of method behaviors as well as
* other behavioral responses.
* MetafacadeLogic for OperationFacade
*
* @see OperationFacade
*/
public abstract class OperationFacadeLogic
extends ModelElementFacadeLogicImpl
implements OperationFacade
{
/**
* The underlying UML object
* @see Operation
*/
protected Operation metaObject;
/** Create Metafacade implementation instance using the MetafacadeFactory from the context
* @param metaObjectIn
* @param context
*/
protected OperationFacadeLogic(Operation metaObjectIn, String context)
{
super(metaObjectIn, getContext(context));
this.metaObject = metaObjectIn;
}
/**
* The logger instance.
*/
private static final Logger logger = Logger.getLogger(OperationFacadeLogic.class);
/**
* Gets the context for this metafacade logic instance.
* @param context String. Set to OperationFacade if null
* @return context String
*/
private static String getContext(String context)
{
if (context == null)
{
context = "org.andromda.metafacades.uml.OperationFacade";
}
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 OperationFacade
*/
public boolean isOperationFacadeMetaType()
{
return true;
}
// --------------- attributes ---------------------
/**
* @see OperationFacade#getSignature()
* @return String
*/
protected abstract String handleGetSignature();
private String __signature1a;
private boolean __signature1aSet = false;
/**
* Return the operation signature, including public/protested abstract returnType name plus
* argument type and name
* @return (String)handleGetSignature()
*/
public final String getSignature()
{
String signature1a = this.__signature1a;
if (!this.__signature1aSet)
{
// signature has no pre constraints
signature1a = handleGetSignature();
// signature has no post constraints
this.__signature1a = signature1a;
if (isMetafacadePropertyCachingEnabled())
{
this.__signature1aSet = true;
}
}
return signature1a;
}
/**
* @see OperationFacade#getCall()
* @return String
*/
protected abstract String handleGetCall();
private String __call2a;
private boolean __call2aSet = false;
/**
* Constructs the operation call with the operation name
* @return (String)handleGetCall()
*/
public final String getCall()
{
String call2a = this.__call2a;
if (!this.__call2aSet)
{
// call has no pre constraints
call2a = handleGetCall();
// call has no post constraints
this.__call2a = call2a;
if (isMetafacadePropertyCachingEnabled())
{
this.__call2aSet = true;
}
}
return call2a;
}
/**
* @see OperationFacade#getTypedArgumentList()
* @return String
*/
protected abstract String handleGetTypedArgumentList();
private String __typedArgumentList3a;
private boolean __typedArgumentList3aSet = false;
/**
* A comma-separated parameter list (type and name of each parameter) of an operation.
* @return (String)handleGetTypedArgumentList()
*/
public final String getTypedArgumentList()
{
String typedArgumentList3a = this.__typedArgumentList3a;
if (!this.__typedArgumentList3aSet)
{
// typedArgumentList has no pre constraints
typedArgumentList3a = handleGetTypedArgumentList();
// typedArgumentList has no post constraints
this.__typedArgumentList3a = typedArgumentList3a;
if (isMetafacadePropertyCachingEnabled())
{
this.__typedArgumentList3aSet = true;
}
}
return typedArgumentList3a;
}
/**
* @see OperationFacade#isStatic()
* @return boolean
*/
protected abstract boolean handleIsStatic();
private boolean __static4a;
private boolean __static4aSet = false;
/**
* True is the operation is static (only a single instance can be instantiated).
* @return (boolean)handleIsStatic()
*/
public final boolean isStatic()
{
boolean static4a = this.__static4a;
if (!this.__static4aSet)
{
// static has no pre constraints
static4a = handleIsStatic();
// static has no post constraints
this.__static4a = static4a;
if (isMetafacadePropertyCachingEnabled())
{
this.__static4aSet = true;
}
}
return static4a;
}
/**
* @see OperationFacade#isAbstract()
* @return boolean
*/
protected abstract boolean handleIsAbstract();
private boolean __abstract5a;
private boolean __abstract5aSet = false;
/**
* True is the operation is abstract.
* @return (boolean)handleIsAbstract()
*/
public final boolean isAbstract()
{
boolean abstract5a = this.__abstract5a;
if (!this.__abstract5aSet)
{
// abstract has no pre constraints
abstract5a = handleIsAbstract();
// abstract has no post constraints
this.__abstract5a = abstract5a;
if (isMetafacadePropertyCachingEnabled())
{
this.__abstract5aSet = true;
}
}
return abstract5a;
}
/**
* @see OperationFacade#getExceptionList()
* @return String
*/
protected abstract String handleGetExceptionList();
private String __exceptionList6a;
private boolean __exceptionList6aSet = false;
/**
* A comma separated list containing all exceptions that this operation throws. Exceptions are
* determined through dependencies that have the target element stereotyped as <<Exception>>.
* @return (String)handleGetExceptionList()
*/
public final String getExceptionList()
{
String exceptionList6a = this.__exceptionList6a;
if (!this.__exceptionList6aSet)
{
// exceptionList has no pre constraints
exceptionList6a = handleGetExceptionList();
// exceptionList has no post constraints
this.__exceptionList6a = exceptionList6a;
if (isMetafacadePropertyCachingEnabled())
{
this.__exceptionList6aSet = true;
}
}
return exceptionList6a;
}
/**
* @see OperationFacade#getExceptions()
* @return Collection<ModelElementFacade>
*/
protected abstract Collection<ModelElementFacade> handleGetExceptions();
private Collection<ModelElementFacade> __exceptions7a;
private boolean __exceptions7aSet = false;
/**
* A collection of all exceptions thrown by this operation.
* @return (Collection<ModelElementFacade>)handleGetExceptions()
*/
public final Collection<ModelElementFacade> getExceptions()
{
Collection<ModelElementFacade> exceptions7a = this.__exceptions7a;
if (!this.__exceptions7aSet)
{
// exceptions has no pre constraints
exceptions7a = handleGetExceptions();
// exceptions has no post constraints
this.__exceptions7a = exceptions7a;
if (isMetafacadePropertyCachingEnabled())
{
this.__exceptions7aSet = true;
}
}
return exceptions7a;
}
/**
* @see OperationFacade#isReturnTypePresent()
* @return boolean
*/
protected abstract boolean handleIsReturnTypePresent();
private boolean __returnTypePresent8a;
private boolean __returnTypePresent8aSet = false;
/**
* True/false depending on whether or not the operation has a return type or not (i.e. a return
* type of something other than void).
* @return (boolean)handleIsReturnTypePresent()
*/
public final boolean isReturnTypePresent()
{
boolean returnTypePresent8a = this.__returnTypePresent8a;
if (!this.__returnTypePresent8aSet)
{
// returnTypePresent has no pre constraints
returnTypePresent8a = handleIsReturnTypePresent();
// returnTypePresent has no post constraints
this.__returnTypePresent8a = returnTypePresent8a;
if (isMetafacadePropertyCachingEnabled())
{
this.__returnTypePresent8aSet = true;
}
}
return returnTypePresent8a;
}
/**
* @see OperationFacade#isExceptionsPresent()
* @return boolean
*/
protected abstract boolean handleIsExceptionsPresent();
private boolean __exceptionsPresent9a;
private boolean __exceptionsPresent9aSet = false;
/**
* True if the operation has (i.e. throws any exceptions) false otherwise.
* @return (boolean)handleIsExceptionsPresent()
*/
public final boolean isExceptionsPresent()
{
boolean exceptionsPresent9a = this.__exceptionsPresent9a;
if (!this.__exceptionsPresent9aSet)
{
// exceptionsPresent has no pre constraints
exceptionsPresent9a = handleIsExceptionsPresent();
// exceptionsPresent has no post constraints
this.__exceptionsPresent9a = exceptionsPresent9a;
if (isMetafacadePropertyCachingEnabled())
{
this.__exceptionsPresent9aSet = true;
}
}
return exceptionsPresent9a;
}
/**
* @see OperationFacade#getArgumentNames()
* @return String
*/
protected abstract String handleGetArgumentNames();
private String __argumentNames10a;
private boolean __argumentNames10aSet = false;
/**
* A comma separated list of all argument names.
* @return (String)handleGetArgumentNames()
*/
public final String getArgumentNames()
{
String argumentNames10a = this.__argumentNames10a;
if (!this.__argumentNames10aSet)
{
// argumentNames has no pre constraints
argumentNames10a = handleGetArgumentNames();
// argumentNames has no post constraints
this.__argumentNames10a = argumentNames10a;
if (isMetafacadePropertyCachingEnabled())
{
this.__argumentNames10aSet = true;
}
}
return argumentNames10a;
}
/**
* @see OperationFacade#getArgumentTypeNames()
* @return String
*/
protected abstract String handleGetArgumentTypeNames();
private String __argumentTypeNames11a;
private boolean __argumentTypeNames11aSet = false;
/**
* A comma separated list of all types of each argument, in order.
* @return (String)handleGetArgumentTypeNames()
*/
public final String getArgumentTypeNames()
{
String argumentTypeNames11a = this.__argumentTypeNames11a;
if (!this.__argumentTypeNames11aSet)
{
// argumentTypeNames has no pre constraints
argumentTypeNames11a = handleGetArgumentTypeNames();
// argumentTypeNames has no post constraints
this.__argumentTypeNames11a = argumentTypeNames11a;
if (isMetafacadePropertyCachingEnabled())
{
this.__argumentTypeNames11aSet = true;
}
}
return argumentTypeNames11a;
}
/**
* @see OperationFacade#isQuery()
* @return boolean
*/
protected abstract boolean handleIsQuery();
private boolean __query12a;
private boolean __query12aSet = false;
/**
* Indicates whether or not this operation is a query operation.
* @return (boolean)handleIsQuery()
*/
public final boolean isQuery()
{
boolean query12a = this.__query12a;
if (!this.__query12aSet)
{
// query has no pre constraints
query12a = handleIsQuery();
// query has no post constraints
this.__query12a = query12a;
if (isMetafacadePropertyCachingEnabled())
{
this.__query12aSet = true;
}
}
return query12a;
}
/**
* @see OperationFacade#getConcurrency()
* @return String
*/
protected abstract String handleGetConcurrency();
private String __concurrency13a;
private boolean __concurrency13aSet = false;
/**
* Returns the concurrency modifier for this operation (i.e. concurrent, guarded or sequential)
* of the model element, will attempt a lookup for these values in the language mappings (if
* any).
* @return (String)handleGetConcurrency()
*/
public final String getConcurrency()
{
String concurrency13a = this.__concurrency13a;
if (!this.__concurrency13aSet)
{
// concurrency has no pre constraints
concurrency13a = handleGetConcurrency();
// concurrency has no post constraints
this.__concurrency13a = concurrency13a;
if (isMetafacadePropertyCachingEnabled())
{
this.__concurrency13aSet = true;
}
}
return concurrency13a;
}
/**
* @see OperationFacade#getPreconditionName()
* @return String
*/
protected abstract String handleGetPreconditionName();
private String __preconditionName14a;
private boolean __preconditionName14aSet = false;
/**
* The name of the operation that handles precondition constraints.
* @return (String)handleGetPreconditionName()
*/
public final String getPreconditionName()
{
String preconditionName14a = this.__preconditionName14a;
if (!this.__preconditionName14aSet)
{
// preconditionName has no pre constraints
preconditionName14a = handleGetPreconditionName();
// preconditionName has no post constraints
this.__preconditionName14a = preconditionName14a;
if (isMetafacadePropertyCachingEnabled())
{
this.__preconditionName14aSet = true;
}
}
return preconditionName14a;
}
/**
* @see OperationFacade#getPostconditionName()
* @return String
*/
protected abstract String handleGetPostconditionName();
private String __postconditionName15a;
private boolean __postconditionName15aSet = false;
/**
* The name of the operation that handles postcondition constraints.
* @return (String)handleGetPostconditionName()
*/
public final String getPostconditionName()
{
String postconditionName15a = this.__postconditionName15a;
if (!this.__postconditionName15aSet)
{
// postconditionName has no pre constraints
postconditionName15a = handleGetPostconditionName();
// postconditionName has no post constraints
this.__postconditionName15a = postconditionName15a;
if (isMetafacadePropertyCachingEnabled())
{
this.__postconditionName15aSet = true;
}
}
return postconditionName15a;
}
/**
* @see OperationFacade#getPreconditionSignature()
* @return String
*/
protected abstract String handleGetPreconditionSignature();
private String __preconditionSignature16a;
private boolean __preconditionSignature16aSet = false;
/**
* The signature of the precondition operation.
* @return (String)handleGetPreconditionSignature()
*/
public final String getPreconditionSignature()
{
String preconditionSignature16a = this.__preconditionSignature16a;
if (!this.__preconditionSignature16aSet)
{
// preconditionSignature has no pre constraints
preconditionSignature16a = handleGetPreconditionSignature();
// preconditionSignature has no post constraints
this.__preconditionSignature16a = preconditionSignature16a;
if (isMetafacadePropertyCachingEnabled())
{
this.__preconditionSignature16aSet = true;
}
}
return preconditionSignature16a;
}
/**
* @see OperationFacade#getPreconditionCall()
* @return String
*/
protected abstract String handleGetPreconditionCall();
private String __preconditionCall17a;
private boolean __preconditionCall17aSet = false;
/**
* The call to the precondition operation.
* @return (String)handleGetPreconditionCall()
*/
public final String getPreconditionCall()
{
String preconditionCall17a = this.__preconditionCall17a;
if (!this.__preconditionCall17aSet)
{
// preconditionCall has no pre constraints
preconditionCall17a = handleGetPreconditionCall();
// preconditionCall has no post constraints
this.__preconditionCall17a = preconditionCall17a;
if (isMetafacadePropertyCachingEnabled())
{
this.__preconditionCall17aSet = true;
}
}
return preconditionCall17a;
}
/**
* @see OperationFacade#isPreconditionsPresent()
* @return boolean
*/
protected abstract boolean handleIsPreconditionsPresent();
private boolean __preconditionsPresent18a;
private boolean __preconditionsPresent18aSet = false;
/**
* Whether any precondition constraints are present on this operation.
* @return (boolean)handleIsPreconditionsPresent()
*/
public final boolean isPreconditionsPresent()
{
boolean preconditionsPresent18a = this.__preconditionsPresent18a;
if (!this.__preconditionsPresent18aSet)
{
// preconditionsPresent has no pre constraints
preconditionsPresent18a = handleIsPreconditionsPresent();
// preconditionsPresent has no post constraints
this.__preconditionsPresent18a = preconditionsPresent18a;
if (isMetafacadePropertyCachingEnabled())
{
this.__preconditionsPresent18aSet = true;
}
}
return preconditionsPresent18a;
}
/**
* @see OperationFacade#isPostconditionsPresent()
* @return boolean
*/
protected abstract boolean handleIsPostconditionsPresent();
private boolean __postconditionsPresent19a;
private boolean __postconditionsPresent19aSet = false;
/**
* Whether any postcondition constraints are present on this operation.
* @return (boolean)handleIsPostconditionsPresent()
*/
public final boolean isPostconditionsPresent()
{
boolean postconditionsPresent19a = this.__postconditionsPresent19a;
if (!this.__postconditionsPresent19aSet)
{
// postconditionsPresent has no pre constraints
postconditionsPresent19a = handleIsPostconditionsPresent();
// postconditionsPresent has no post constraints
this.__postconditionsPresent19a = postconditionsPresent19a;
if (isMetafacadePropertyCachingEnabled())
{
this.__postconditionsPresent19aSet = true;
}
}
return postconditionsPresent19a;
}
/**
* @see OperationFacade#getLower()
* @return int
*/
protected abstract int handleGetLower();
private int __lower20a;
private boolean __lower20aSet = false;
/**
* the lower value for the multiplicity
* -only applicable for UML2
* @return (int)handleGetLower()
*/
public final int getLower()
{
int lower20a = this.__lower20a;
if (!this.__lower20aSet)
{
// lower has no pre constraints
lower20a = handleGetLower();
// lower has no post constraints
this.__lower20a = lower20a;
if (isMetafacadePropertyCachingEnabled())
{
this.__lower20aSet = true;
}
}
return lower20a;
}
/**
* @see OperationFacade#getUpper()
* @return int
*/
protected abstract int handleGetUpper();
private int __upper21a;
private boolean __upper21aSet = false;
/**
* the upper value for the multiplicity (will be -1 for *)
* - only applicable for UML2
* @return (int)handleGetUpper()
*/
public final int getUpper()
{
int upper21a = this.__upper21a;
if (!this.__upper21aSet)
{
// upper has no pre constraints
upper21a = handleGetUpper();
// upper has no post constraints
this.__upper21a = upper21a;
if (isMetafacadePropertyCachingEnabled())
{
this.__upper21aSet = true;
}
}
return upper21a;
}
/**
* @see OperationFacade#getReturnParameter()
* @return ParameterFacade
*/
protected abstract ParameterFacade handleGetReturnParameter();
private ParameterFacade __returnParameter22a;
private boolean __returnParameter22aSet = false;
/**
* (UML2 Only). Get the actual return parameter (which may have stereotypes etc).
* @return (ParameterFacade)handleGetReturnParameter()
*/
public final ParameterFacade getReturnParameter()
{
ParameterFacade returnParameter22a = this.__returnParameter22a;
if (!this.__returnParameter22aSet)
{
// returnParameter has no pre constraints
returnParameter22a = handleGetReturnParameter();
// returnParameter has no post constraints
this.__returnParameter22a = returnParameter22a;
if (isMetafacadePropertyCachingEnabled())
{
this.__returnParameter22aSet = true;
}
}
return returnParameter22a;
}
/**
* @see OperationFacade#isOverriding()
* @return boolean
*/
protected abstract boolean handleIsOverriding();
private boolean __overriding23a;
private boolean __overriding23aSet = false;
/**
* True if this operation overrides an operation defined in an ancestor class. An operation
* overrides when the names of the operations as well as the types of the arguments are equal.
* The return type may be different and is, as well as any exceptions, ignored.
* @return (boolean)handleIsOverriding()
*/
public final boolean isOverriding()
{
boolean overriding23a = this.__overriding23a;
if (!this.__overriding23aSet)
{
// overriding has no pre constraints
overriding23a = handleIsOverriding();
// overriding has no post constraints
this.__overriding23a = overriding23a;
if (isMetafacadePropertyCachingEnabled())
{
this.__overriding23aSet = true;
}
}
return overriding23a;
}
/**
* @see OperationFacade#isOrdered()
* @return boolean
*/
protected abstract boolean handleIsOrdered();
private boolean __ordered24a;
private boolean __ordered24aSet = false;
/**
* UML2 only: If isMany (Collection type returned), is the type unique within the collection.
* Unique+Ordered determines CollectionType implementation of return result. Default=false.
* @return (boolean)handleIsOrdered()
*/
public final boolean isOrdered()
{
boolean ordered24a = this.__ordered24a;
if (!this.__ordered24aSet)
{
// ordered has no pre constraints
ordered24a = handleIsOrdered();
// ordered has no post constraints
this.__ordered24a = ordered24a;
if (isMetafacadePropertyCachingEnabled())
{
this.__ordered24aSet = true;
}
}
return ordered24a;
}
/**
* @see OperationFacade#getGetterSetterReturnTypeName()
* @return String
*/
protected abstract String handleGetGetterSetterReturnTypeName();
private String __getterSetterReturnTypeName25a;
private boolean __getterSetterReturnTypeName25aSet = false;
/**
* Return Type with multiplicity taken into account. UML14 does not allow multiplicity *.
* @return (String)handleGetGetterSetterReturnTypeName()
*/
public final String getGetterSetterReturnTypeName()
{
String getterSetterReturnTypeName25a = this.__getterSetterReturnTypeName25a;
if (!this.__getterSetterReturnTypeName25aSet)
{
// getterSetterReturnTypeName has no pre constraints
getterSetterReturnTypeName25a = handleGetGetterSetterReturnTypeName();
// getterSetterReturnTypeName has no post constraints
this.__getterSetterReturnTypeName25a = getterSetterReturnTypeName25a;
if (isMetafacadePropertyCachingEnabled())
{
this.__getterSetterReturnTypeName25aSet = true;
}
}
return getterSetterReturnTypeName25a;
}
/**
* @see OperationFacade#isMany()
* @return boolean
*/
protected abstract boolean handleIsMany();
private boolean __many26a;
private boolean __many26aSet = false;
/**
* UML2 only. If the return type parameter multiplicity>1 OR the operation multiplicity>1.
* Default=false.
* @return (boolean)handleIsMany()
*/
public final boolean isMany()
{
boolean many26a = this.__many26a;
if (!this.__many26aSet)
{
// many has no pre constraints
many26a = handleIsMany();
// many has no post constraints
this.__many26a = many26a;
if (isMetafacadePropertyCachingEnabled())
{
this.__many26aSet = true;
}
}
return many26a;
}
/**
* @see OperationFacade#isUnique()
* @return boolean
*/
protected abstract boolean handleIsUnique();
private boolean __unique27a;
private boolean __unique27aSet = false;
/**
* UML2 only: for Collection return type, is the type unique within the collection.
* Unique+Ordered determines the returned CollectionType. Default=false.
* @return (boolean)handleIsUnique()
*/
public final boolean isUnique()
{
boolean unique27a = this.__unique27a;
if (!this.__unique27aSet)
{
// unique has no pre constraints
unique27a = handleIsUnique();
// unique has no post constraints
this.__unique27a = unique27a;
if (isMetafacadePropertyCachingEnabled())
{
this.__unique27aSet = true;
}
}
return unique27a;
}
/**
* @see OperationFacade#isLeaf()
* @return boolean
*/
protected abstract boolean handleIsLeaf();
private boolean __leaf28a;
private boolean __leaf28aSet = false;
/**
* IsLeaf property in the operation. If true, operation is final, cannot be extended or
* implemented by a descendant. Default=false.
* @return (boolean)handleIsLeaf()
*/
public final boolean isLeaf()
{
boolean leaf28a = this.__leaf28a;
if (!this.__leaf28aSet)
{
// leaf has no pre constraints
leaf28a = handleIsLeaf();
// leaf has no post constraints
this.__leaf28a = leaf28a;
if (isMetafacadePropertyCachingEnabled())
{
this.__leaf28aSet = true;
}
}
return leaf28a;
}
/**
* @see OperationFacade#getMethodBody()
* @return String
*/
protected abstract String handleGetMethodBody();
private String __methodBody29a;
private boolean __methodBody29aSet = false;
/**
* Returns the operation method body determined from UML sequence diagrams or other UML sources.
* @return (String)handleGetMethodBody()
*/
public final String getMethodBody()
{
String methodBody29a = this.__methodBody29a;
if (!this.__methodBody29aSet)
{
// methodBody has no pre constraints
methodBody29a = handleGetMethodBody();
// methodBody has no post constraints
this.__methodBody29a = methodBody29a;
if (isMetafacadePropertyCachingEnabled())
{
this.__methodBody29aSet = true;
}
}
return methodBody29a;
}
// ---------------- 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 operation
* 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 operation
* to the class itself and then up the class hierarchy.
* @param name String
* The name of the tagged value to find.
* @param follow boolean
* TODO: Model Documentation for
* OperationFacade.findTaggedValue(follow)
* @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;
}
/**
* Method to be implemented in descendants
* Returns a comma separated list of exceptions appended to the comma separated list of fully
* qualified 'initialException' classes passed in to this method.
* @param initialExceptions
* @return String
*/
protected abstract String handleGetExceptionList(String initialExceptions);
/**
* Returns a comma separated list of exceptions appended to the comma separated list of fully
* qualified 'initialException' classes passed in to this method.
* @param initialExceptions String
* A comma separated list of fully qualified 'initialException' classes passed in to this
* method.
* @return handleGetExceptionList(initialExceptions)
*/
public String getExceptionList(String initialExceptions)
{
// getExceptionList has no pre constraints
String returnValue = handleGetExceptionList(initialExceptions);
// getExceptionList has no post constraints
return returnValue;
}
/**
* Method to be implemented in descendants
* Returns the signature of the operation and optionally appends the argument names (if
* withArgumentNames is true), otherwise returns the signature with just the types alone in the
* signature.
* @param withArgumentNames
* @return String
*/
protected abstract String handleGetSignature(boolean withArgumentNames);
/**
* Returns the signature of the operation and optionally appends the argument names (if
* withArgumentNames is true), otherwise returns the signature with just the types alone in the
* signature.
* @param withArgumentNames boolean
* TODO: Model Documentation for
* OperationFacade.getSignature(withArgumentNames)
* @return handleGetSignature(withArgumentNames)
*/
public String getSignature(boolean withArgumentNames)
{
// getSignature has no pre constraints
String returnValue = handleGetSignature(withArgumentNames);
// getSignature has no post constraints
return returnValue;
}
/**
* Method to be implemented in descendants
* A comma-separated parameter list (type and name of each parameter) of an operation with an
* optional modifier (i.e final) before each parameter.
* @param modifier
* @return String
*/
protected abstract String handleGetTypedArgumentList(String modifier);
/**
* A comma-separated parameter list (type and name of each parameter) of an operation with an
* optional modifier (i.e final) before each parameter.
* @param modifier String
* The modifier to prefix the arguments with (i.e. 'final')
* @return handleGetTypedArgumentList(modifier)
*/
public String getTypedArgumentList(String modifier)
{
// getTypedArgumentList has no pre constraints
String returnValue = handleGetTypedArgumentList(modifier);
// getTypedArgumentList has no post constraints
return returnValue;
}
/**
* Method to be implemented in descendants
* Returns the signature of the operation and optionally appends the given 'argumentModifier' to
* each argument.
* @param argumentModifier
* @return String
*/
protected abstract String handleGetSignature(String argumentModifier);
/**
* Returns the signature of the operation and optionally appends the given 'argumentModifier' to
* each argument.
* @param argumentModifier String
* The modifier to give the arguments (i.e. 'final').
* @return handleGetSignature(argumentModifier)
*/
public String getSignature(String argumentModifier)
{
// getSignature has no pre constraints
String returnValue = handleGetSignature(argumentModifier);
// getSignature has no post constraints
return returnValue;
}
/**
* Method to be implemented in descendants
* Finds the parameter on this operation having the given name, if no parameter is found, null
* is returned instead.
* @param name
* @return ParameterFacade
*/
protected abstract ParameterFacade handleFindParameter(String name);
/**
* Finds the parameter on this operation having the given name, if no parameter is found, null
* is returned instead.
* @param name String
* The name of the parameter to find on the owner operation.
* @return handleFindParameter(name)
*/
public ParameterFacade findParameter(String name)
{
// findParameter has no pre constraints
ParameterFacade returnValue = handleFindParameter(name);
// findParameter has no post constraints
return returnValue;
}
// ------------- associations ------------------
/**
* A behavioral feature of a classifier that specifies the name, type, parameters, and
* constraints for
* invoking an associated behavior. May invoke both the execution of method behaviors as well as
* other
* behavioral responses.
* @return (Collection<ConstraintFacade>)handleGetPostconditions()
*/
public final Collection<ConstraintFacade> getPostconditions()
{
Collection<ConstraintFacade> getPostconditions1r = null;
// operationFacade has no pre constraints
Collection result = handleGetPostconditions();
List shieldedResult = this.shieldedElements(result);
try
{
getPostconditions1r = (Collection<ConstraintFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
OperationFacadeLogic.logger.warn("incorrect metafacade cast for OperationFacadeLogic.getPostconditions Collection<ConstraintFacade> " + result + ": " + shieldedResult);
}
// operationFacade has no post constraints
return getPostconditions1r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return Collection
*/
protected abstract Collection handleGetPostconditions();
/**
* A behavioral feature of a classifier that specifies the name, type, parameters, and
* constraints for
* invoking an associated behavior. May invoke both the execution of method behaviors as well as
* other
* behavioral responses.
* @return (Collection<ParameterFacade>)handleGetArguments()
*/
public final Collection<ParameterFacade> getArguments()
{
Collection<ParameterFacade> getArguments2r = null;
// operationFacade has no pre constraints
Collection result = handleGetArguments();
List shieldedResult = this.shieldedElements(result);
try
{
getArguments2r = (Collection<ParameterFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
OperationFacadeLogic.logger.warn("incorrect metafacade cast for OperationFacadeLogic.getArguments Collection<ParameterFacade> " + result + ": " + shieldedResult);
}
// operationFacade has no post constraints
return getArguments2r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return Collection
*/
protected abstract Collection handleGetArguments();
/**
* The operations owned by this classifier.
* @return (ClassifierFacade)handleGetOwner()
*/
public final ClassifierFacade getOwner()
{
ClassifierFacade getOwner3r = null;
// operations 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
OperationFacadeLogic.logger.warn("incorrect metafacade cast for OperationFacadeLogic.getOwner ClassifierFacade " + result + ": " + shieldedResult);
}
// operations has no post constraints
return getOwner3r;
}
/**
* UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
* @return Object
*/
protected abstract Object handleGetOwner();
/**
* If this parameter is located on an operation, this will represent that operation.
* @return (Collection<ParameterFacade>)handleGetParameters()
*/
public final Collection<ParameterFacade> getParameters()
{
Collection<ParameterFacade> getParameters4r = null;
// operation has no pre constraints
Collection result = handleGetParameters();
List shieldedResult = this.shieldedElements(result);
try
{
getParameters4r = (Collection<ParameterFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
OperationFacadeLogic.logger.warn("incorrect metafacade cast for OperationFacadeLogic.getParameters Collection<ParameterFacade> " + result + ": " + shieldedResult);
}
// operation has no post constraints
return getParameters4r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return Collection
*/
protected abstract Collection handleGetParameters();
/**
* A behavioral feature of a classifier that specifies the name, type, parameters, and
* constraints for
* invoking an associated behavior. May invoke both the execution of method behaviors as well as
* other
* behavioral responses.
* @return (ClassifierFacade)handleGetReturnType()
*/
public final ClassifierFacade getReturnType()
{
ClassifierFacade getReturnType5r = null;
// operationFacade has no pre constraints
Object result = handleGetReturnType();
MetafacadeBase shieldedResult = this.shieldedElement(result);
try
{
getReturnType5r = (ClassifierFacade)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
OperationFacadeLogic.logger.warn("incorrect metafacade cast for OperationFacadeLogic.getReturnType ClassifierFacade " + result + ": " + shieldedResult);
}
// operationFacade has no post constraints
return getReturnType5r;
}
/**
* UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
* @return Object
*/
protected abstract Object handleGetReturnType();
/**
* A behavioral feature of a classifier that specifies the name, type, parameters, and
* constraints for
* invoking an associated behavior. May invoke both the execution of method behaviors as well as
* other
* behavioral responses.
* @return (Collection<ConstraintFacade>)handleGetPreconditions()
*/
public final Collection<ConstraintFacade> getPreconditions()
{
Collection<ConstraintFacade> getPreconditions6r = null;
// operationFacade has no pre constraints
Collection result = handleGetPreconditions();
List shieldedResult = this.shieldedElements(result);
try
{
getPreconditions6r = (Collection<ConstraintFacade>)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
OperationFacadeLogic.logger.warn("incorrect metafacade cast for OperationFacadeLogic.getPreconditions Collection<ConstraintFacade> " + result + ": " + shieldedResult);
}
// operationFacade has no post constraints
return getPreconditions6r;
}
/**
* UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
* @return Collection
*/
protected abstract Collection handleGetPreconditions();
private OperationFacade __getOverriddenOperation7r;
private boolean __getOverriddenOperation7rSet = false;
/**
* A behavioral feature of a classifier that specifies the name, type, parameters, and
* constraints for
* invoking an associated behavior. May invoke both the execution of method behaviors as well as
* other
* behavioral responses.
* @return (OperationFacade)handleGetOverriddenOperation()
*/
public final OperationFacade getOverriddenOperation()
{
OperationFacade getOverriddenOperation7r = this.__getOverriddenOperation7r;
if (!this.__getOverriddenOperation7rSet)
{
// operationFacade has no pre constraints
Object result = handleGetOverriddenOperation();
MetafacadeBase shieldedResult = this.shieldedElement(result);
try
{
getOverriddenOperation7r = (OperationFacade)shieldedResult;
}
catch (ClassCastException ex)
{
// Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
OperationFacadeLogic.logger.warn("incorrect metafacade cast for OperationFacadeLogic.getOverriddenOperation OperationFacade " + result + ": " + shieldedResult);
}
// operationFacade has no post constraints
this.__getOverriddenOperation7r = getOverriddenOperation7r;
if (isMetafacadePropertyCachingEnabled())
{
this.__getOverriddenOperation7rSet = true;
}
}
return getOverriddenOperation7r;
}
/**
* UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
* @return Object
*/
protected abstract Object handleGetOverriddenOperation();
/**
* <p><b>Constraint:</b> org::andromda::metafacades::uml::OperationFacade::operation needs a return type</p>
* <p><b>Error:</b> Each operation needs a return type, you cannot leave the type unspecified, even if you want void you'll need to explicitly specify it.</p>
* <p><b>OCL:</b> context OperationFacade
inv: returnType.name->notEmpty()</p>
* <p><b>Constraint:</b> org::andromda::metafacades::uml::OperationFacade::operation must have a name</p>
* <p><b>Error:</b> Each operation must have a non-empty name.</p>
* <p><b>OCL:</b> context OperationFacade
inv: name -> notEmpty()</p>
* <p><b>Constraint:</b> org::andromda::metafacades::uml::OperationFacade::primitive operation return cannot be used in a Collection</p>
* <p><b>Error:</b> Primitive return parameters cannot be used in Collections (multiplicity > 1). Use the wrapped type or Array type instead.</p>
* <p><b>OCL:</b> context OperationFacade inv: returnParameter.type.primitive implies (many = false)</p>
* <p><b>Constraint:</b> org::andromda::metafacades::uml::OperationFacade::wrapped primitive operation return should not be required</p>
* <p><b>Error:</b> Wrapped primitive operation return must have a multiplicity lower bound = 0 (must be optional). Use the unwrapped type, or change the multiplicity.</p>
* <p><b>OCL:</b> context OperationFacade inv: returnParameter.type.wrappedPrimitive and many = false implies (lower = 0)</p>
* <p><b>Constraint:</b> org::andromda::metafacades::uml::OperationFacade::primitive operation return must be required</p>
* <p><b>Error:</b> Primitive operation return types must have a multiplicity lower bound > 0 (must be required). Use a wrapped type, or change the multiplicity.</p>
* <p><b>OCL:</b> context OperationFacade inv: returnParameter.type.primitive implies (lower > 0)</p>
* <p><b>Constraint:</b> org::andromda::metafacades::uml::OperationFacade::operation multiplicity must match return parameter multiplicity</p>
* <p><b>Error:</b> Operation return parameter with multiplicity greater than 1 must match the operation multiplicity greater than 1.</p>
* <p><b>OCL:</b> context OperationFacade
inv: many implies (returnParameter.many)</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,"returnType.name")));
if (!constraintValid)
{
validationMessages.add(
new ModelValidationMessage(
(MetafacadeBase)contextElement ,
"org::andromda::metafacades::uml::OperationFacade::operation needs a return type",
"Each operation needs a return type, you cannot leave the type unspecified, even if you want void you'll need to explicitly specify it."));
}
}
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::OperationFacade::operation needs a return 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::OperationFacade::operation must have a name",
"Each operation 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::OperationFacade::operation 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,"returnParameter.type.primitive"))).booleanValue()?(OCLExpressions.equal(OCLIntrospector.invoke(contextElement,"many"),false)):true));
if (!constraintValid)
{
validationMessages.add(
new ModelValidationMessage(
(MetafacadeBase)contextElement ,
"org::andromda::metafacades::uml::OperationFacade::primitive operation return cannot be used in a Collection",
"Primitive return parameters cannot be used in Collections (multiplicity > 1). Use the wrapped type or Array 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::OperationFacade::primitive operation return cannot be used in a 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,"returnParameter.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::OperationFacade::wrapped primitive operation return should not be required",
"Wrapped primitive operation return 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::OperationFacade::wrapped primitive operation return should not 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,"returnParameter.type.primitive"))).booleanValue()?(OCLExpressions.greater(OCLIntrospector.invoke(contextElement,"lower"),0)):true));
if (!constraintValid)
{
validationMessages.add(
new ModelValidationMessage(
(MetafacadeBase)contextElement ,
"org::andromda::metafacades::uml::OperationFacade::primitive operation return must be required",
"Primitive operation return types 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::OperationFacade::primitive operation return 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,"many"))).booleanValue()?(OCLIntrospector.invoke(contextElement,"returnParameter.many")):true));
if (!constraintValid)
{
validationMessages.add(
new ModelValidationMessage(
(MetafacadeBase)contextElement ,
"org::andromda::metafacades::uml::OperationFacade::operation multiplicity must match return parameter multiplicity",
"Operation return parameter with multiplicity greater than 1 must match the operation multiplicity greater than 1."));
}
}
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::OperationFacade::operation multiplicity must match return parameter multiplicity' ON "
+ this.THIS().toString() + ": " + th.getMessage(), th);
}
}
}