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