// 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);
         }
     }
 }