// license-header java merge-point
   //
   // Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
   //
   package org.andromda.cartridges.bpm4struts.metafacades;
   
   import java.util.Collection;
   import org.andromda.core.common.Introspector;
   import org.andromda.core.metafacade.MetafacadeBase;
  import org.andromda.core.metafacade.MetafacadeFactory;
  import org.andromda.core.metafacade.ModelValidationMessage;
  import org.andromda.metafacades.uml.AttributeFacade;
  import org.andromda.metafacades.uml.ClassifierFacade;
  import org.andromda.metafacades.uml.ConstraintFacade;
  import org.andromda.metafacades.uml.DependencyFacade;
  import org.andromda.metafacades.uml.EnumerationFacade;
  import org.andromda.metafacades.uml.ModelElementFacade;
  import org.andromda.metafacades.uml.ModelFacade;
  import org.andromda.metafacades.uml.PackageFacade;
  import org.andromda.metafacades.uml.StateMachineFacade;
  import org.andromda.metafacades.uml.StereotypeFacade;
  import org.andromda.metafacades.uml.TaggedValueFacade;
  import org.andromda.metafacades.uml.TemplateParameterFacade;
  import org.andromda.metafacades.uml.TypeMappings;
  import org.andromda.translation.ocl.validation.OCLIntrospector;
  import org.andromda.translation.ocl.validation.OCLResultEnsurer;
  import org.apache.log4j.Logger;
  
  /**
   * TODO: Model Documentation for org.andromda.cartridges.bpm4struts.metafacades.StrutsAttribute
   * MetafacadeLogic for StrutsAttribute
   *
   * @see StrutsAttribute
   */
  public abstract class StrutsAttributeLogic
      extends MetafacadeBase
      implements StrutsAttribute
  {
      /**
       * The underlying UML object
       * @see Object
       */
      protected Object metaObject;
  
      /** Create Metafacade implementation instance using the MetafacadeFactory from the context
       * @param metaObjectIn
       * @param context
       */
      protected StrutsAttributeLogic(Object metaObjectIn, String context)
      {
          super(metaObjectIn, getContext(context));
          this.superAttributeFacade =
             (AttributeFacade)
              MetafacadeFactory.getInstance().createFacadeImpl(
                      "org.andromda.metafacades.uml.AttributeFacade",
                      metaObjectIn,
                      getContext(context));
          this.metaObject = metaObjectIn;
      }
  
      /**
       * The logger instance.
       */
      private static final Logger logger = Logger.getLogger(StrutsAttributeLogic.class);
  
      /**
       * Gets the context for this metafacade logic instance.
       * @param context String. Set to StrutsAttribute if null
       * @return context String
       */
      private static String getContext(String context)
      {
          if (context == null)
          {
              context = "org.andromda.cartridges.bpm4struts.metafacades.StrutsAttribute";
          }
          return context;
      }
  
      private AttributeFacade superAttributeFacade;
      private boolean superAttributeFacadeInitialized = false;
  
      /**
       * Gets the AttributeFacade parent instance.
       * @return this.superAttributeFacade AttributeFacade
       */
      private AttributeFacade getSuperAttributeFacade()
      {
          if (!this.superAttributeFacadeInitialized)
          {
              ((MetafacadeBase)this.superAttributeFacade).setMetafacadeContext(this.getMetafacadeContext());
              this.superAttributeFacadeInitialized = true;
          }
          return this.superAttributeFacade;
      }
  
      /** Reset context only for non-root metafacades
       * @param context
       * @see MetafacadeBase#resetMetafacadeContext(String 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);
             if (this.superAttributeFacadeInitialized)
             {
                 ((MetafacadeBase)this.superAttributeFacade).resetMetafacadeContext(context);
             }
         }
     }
 
     /**
      * @return boolean true always
      * @see StrutsAttribute
      */
     public boolean isStrutsAttributeMetaType()
     {
         return true;
     }
 
     // --------------- attributes ---------------------
 
    /**
     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAttribute#getDateFormat()
     * @return String
     */
     protected abstract String handleGetDateFormat();
 
     private String __dateFormat1a;
     private boolean __dateFormat1aSet = false;
 
     /**
      * If this attribute is a date type this property represents the format in which this date is to
      * be presented to the end-user. Null otherwise.
      * @return (String)handleGetDateFormat()
      */
     public final String getDateFormat()
     {
         String dateFormat1a = this.__dateFormat1a;
         if (!this.__dateFormat1aSet)
         {
             // dateFormat has no pre constraints
             dateFormat1a = handleGetDateFormat();
             // dateFormat has no post constraints
             this.__dateFormat1a = dateFormat1a;
             if (isMetafacadePropertyCachingEnabled())
             {
                 this.__dateFormat1aSet = true;
             }
         }
         return dateFormat1a;
     }
 
    /**
     * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsAttribute#isSafeNamePresent()
     * @return boolean
     */
     protected abstract boolean handleIsSafeNamePresent();
 
     private boolean __safeNamePresent2a;
     private boolean __safeNamePresent2aSet = false;
 
     /**
      * True if this parameter has a name that can properly be handled by Jakarta commons (this lib
      * is used by Struts but contains a bug)
      * @return (boolean)handleIsSafeNamePresent()
      */
     public final boolean isSafeNamePresent()
     {
         boolean safeNamePresent2a = this.__safeNamePresent2a;
         if (!this.__safeNamePresent2aSet)
         {
             // safeNamePresent has no pre constraints
             safeNamePresent2a = handleIsSafeNamePresent();
             // safeNamePresent has no post constraints
             this.__safeNamePresent2a = safeNamePresent2a;
             if (isMetafacadePropertyCachingEnabled())
             {
                 this.__safeNamePresent2aSet = true;
             }
         }
         return safeNamePresent2a;
     }
 
     // ---------------- business methods ----------------------
 
     /**
      * Method to be implemented in descendants
      * TODO: Model Documentation for
      * org.andromda.cartridges.bpm4struts.metafacades.StrutsAttribute.getDummyValue
      * @param seed
      * @return String
      */
     protected abstract String handleGetDummyValue(int seed);
 
     /**
      * TODO: Model Documentation for
      * org.andromda.cartridges.bpm4struts.metafacades.StrutsAttribute.getDummyValue
      * @param seed int
      * TODO: Model Documentation for
      * org.andromda.cartridges.bpm4struts.metafacades.StrutsAttribute.getDummyValue(seed)
      * @return handleGetDummyValue(seed)
      */
     public String getDummyValue(int seed)
     {
         // getDummyValue has no pre constraints
         String returnValue = handleGetDummyValue(seed);
         // getDummyValue has no post constraints
         return returnValue;
     }
 
     /**
      * @return true
      * @see AttributeFacade
      */
     public boolean isAttributeFacadeMetaType()
     {
         return true;
     }
 
     /**
      * @return true
      * @see ModelElementFacade
      */
     public boolean isModelElementFacadeMetaType()
     {
         return true;
     }
 
     // ----------- delegates to AttributeFacade ------------
     /**
      * 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.
      * @see AttributeFacade#findTaggedValue(String name, boolean follow)
      */
     public Object findTaggedValue(String name, boolean follow)
     {
         return this.getSuperAttributeFacade().findTaggedValue(name, follow);
     }
 
     /**
      * The default value of the attribute.  This is the value given if no value is defined.
      * @see AttributeFacade#getDefaultValue()
      */
     public String getDefaultValue()
     {
         return this.getSuperAttributeFacade().getDefaultValue();
     }
 
     /**
      * If the attribute is an enumeration literal this represents the owning enumeration. Can be
      * empty.
      * @see AttributeFacade#getEnumeration()
      */
     public EnumerationFacade getEnumeration()
     {
         return this.getSuperAttributeFacade().getEnumeration();
     }
 
     /**
      * Returns the enumeration literal parameters defined by tagged value as a comma separated list.
      * @see AttributeFacade#getEnumerationLiteralParameters()
      */
     public String getEnumerationLiteralParameters()
     {
         return this.getSuperAttributeFacade().getEnumerationLiteralParameters();
     }
 
     /**
      * 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.
      * @see AttributeFacade#getEnumerationValue()
      */
     public String getEnumerationValue()
     {
         return this.getSuperAttributeFacade().getEnumerationValue();
     }
 
     /**
      * The name of the accessor operation that would retrieve this attribute's value.
      * @see AttributeFacade#getGetterName()
      */
     public String getGetterName()
     {
         return this.getSuperAttributeFacade().getGetterName();
     }
 
     /**
      * The name of the type that is returned on the accessor and mutator operations,  determined in
      * part by the multiplicity.
      * @see AttributeFacade#getGetterSetterTypeName()
      */
     public String getGetterSetterTypeName()
     {
         return this.getSuperAttributeFacade().getGetterSetterTypeName();
     }
 
     /**
      * the lower value for the multiplicity
      * -only applicable for UML2
      * @see AttributeFacade#getLower()
      */
     public int getLower()
     {
         return this.getSuperAttributeFacade().getLower();
     }
 
     /**
      * Gets the classifier who is the owner of the attributes.
      * @see AttributeFacade#getOwner()
      */
     public ClassifierFacade getOwner()
     {
         return this.getSuperAttributeFacade().getOwner();
     }
 
     /**
      * The name of the mutator operation that would retrieve this attribute's value.
      * @see AttributeFacade#getSetterName()
      */
     public String getSetterName()
     {
         return this.getSuperAttributeFacade().getSetterName();
     }
 
     /**
      * The classifier owning this attribute.
      * @see AttributeFacade#getType()
      */
     public ClassifierFacade getType()
     {
         return this.getSuperAttributeFacade().getType();
     }
 
     /**
      * the upper value for the multiplicity (will be -1 for *)
      * -only applicable for UML2
      * @see AttributeFacade#getUpper()
      */
     public int getUpper()
     {
         return this.getSuperAttributeFacade().getUpper();
     }
 
     /**
      * True if this attribute can only be set.
      * @see AttributeFacade#isAddOnly()
      */
     public boolean isAddOnly()
     {
         return this.getSuperAttributeFacade().isAddOnly();
     }
 
     /**
      * True if this attribute can be modified.
      * @see AttributeFacade#isChangeable()
      */
     public boolean isChangeable()
     {
         return this.getSuperAttributeFacade().isChangeable();
     }
 
     /**
      * Indicates if the default value is present.
      * @see AttributeFacade#isDefaultValuePresent()
      */
     public boolean isDefaultValuePresent()
     {
         return this.getSuperAttributeFacade().isDefaultValuePresent();
     }
 
     /**
      * If the attribute is derived (its value is computed). UML2 only. UML14 always returns false.
      * Default=false.
      * @see AttributeFacade#isDerived()
      */
     public boolean isDerived()
     {
         return this.getSuperAttributeFacade().isDerived();
     }
 
     /**
      * True if this attribute is owned by an enumeration.
      * @see AttributeFacade#isEnumerationLiteral()
      */
     public boolean isEnumerationLiteral()
     {
         return this.getSuperAttributeFacade().isEnumerationLiteral();
     }
 
     /**
      * Returns true if enumeration literal parameters exist (defined by tagged value) for the
      * literal.
      * @see AttributeFacade#isEnumerationLiteralParametersExist()
      */
     public boolean isEnumerationLiteralParametersExist()
     {
         return this.getSuperAttributeFacade().isEnumerationLiteralParametersExist();
     }
 
     /**
      * True if this attribute is owned by an enumeration but is defined as a member variable (NOT a
      * literal).
      * @see AttributeFacade#isEnumerationMember()
      */
     public boolean isEnumerationMember()
     {
         return this.getSuperAttributeFacade().isEnumerationMember();
     }
 
     /**
      * IsLeaf property in the operation. If true, operation is final, cannot be extended or
      * implemented by a descendant.
      * @see AttributeFacade#isLeaf()
      */
     public boolean isLeaf()
     {
         return this.getSuperAttributeFacade().isLeaf();
     }
 
     /**
      * Whether or not this attribute has a multiplicity greater than 1.
      * @see AttributeFacade#isMany()
      */
     public boolean isMany()
     {
         return this.getSuperAttributeFacade().isMany();
     }
 
     /**
      * Indicates whether or not the attributes are ordered (if multiplicity is greater than 1).
      * @see AttributeFacade#isOrdered()
      */
     public boolean isOrdered()
     {
         return this.getSuperAttributeFacade().isOrdered();
     }
 
     /**
      * Whether or not this attribute can be modified.
      * @see AttributeFacade#isReadOnly()
      */
     public boolean isReadOnly()
     {
         return this.getSuperAttributeFacade().isReadOnly();
     }
 
     /**
      * Whether or not the multiplicity of this attribute is 1.
      * @see AttributeFacade#isRequired()
      */
     public boolean isRequired()
     {
         return this.getSuperAttributeFacade().isRequired();
     }
 
     /**
      * Indicates if this attribute is 'static', meaning it has a classifier scope.
      * @see AttributeFacade#isStatic()
      */
     public boolean isStatic()
     {
         return this.getSuperAttributeFacade().isStatic();
     }
 
     /**
      * If the attribute is unique within the Collection type. UML2 only. UML14 always returns false.
      * Unique+Ordered determines the implementation Collection type. Default=false.
      * @see AttributeFacade#isUnique()
      */
     public boolean isUnique()
     {
         return this.getSuperAttributeFacade().isUnique();
     }
 
     /**
      * Copies all tagged values from the given ModelElementFacade to this model element facade.
      * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element)
      */
     public void copyTaggedValues(ModelElementFacade element)
     {
         this.getSuperAttributeFacade().copyTaggedValues(element);
     }
 
     /**
      * Finds the tagged value with the specified 'tagName'. In case there are more values the first
      * one found will be returned.
      * @see ModelElementFacade#findTaggedValue(String tagName)
      */
     public Object findTaggedValue(String tagName)
     {
         return this.getSuperAttributeFacade().findTaggedValue(tagName);
     }
 
     /**
      * Returns all the values for the tagged value with the specified name. The returned collection
      * will contains only String instances, or will be empty. Never null.
      * @see ModelElementFacade#findTaggedValues(String tagName)
      */
     public Collection<Object> findTaggedValues(String tagName)
     {
         return this.getSuperAttributeFacade().findTaggedValues(tagName);
     }
 
     /**
      * Returns the fully qualified name of the model element. The fully qualified name includes
      * complete package qualified name of the underlying model element. The templates parameter will
      * be replaced by the correct one given the binding relation of the parameter to this element.
      * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement)
      */
     public String getBindedFullyQualifiedName(ModelElementFacade bindedElement)
     {
         return this.getSuperAttributeFacade().getBindedFullyQualifiedName(bindedElement);
     }
 
     /**
      * Gets all constraints belonging to the model element.
      * @see ModelElementFacade#getConstraints()
      */
     public Collection<ConstraintFacade> getConstraints()
     {
         return this.getSuperAttributeFacade().getConstraints();
     }
 
     /**
      * Returns the constraints of the argument kind that have been placed onto this model. Typical
      * kinds are "inv", "pre" and "post". Other kinds are possible.
      * @see ModelElementFacade#getConstraints(String kind)
      */
     public Collection<ConstraintFacade> getConstraints(String kind)
     {
         return this.getSuperAttributeFacade().getConstraints(kind);
     }
 
     /**
      * Gets the documentation for the model element, The indent argument is prefixed to each line.
      * By default this method wraps lines after 64 characters.
      * This method is equivalent to <code>getDocumentation(indent, 64)</code>.
      * @see ModelElementFacade#getDocumentation(String indent)
      */
     public String getDocumentation(String indent)
     {
         return this.getSuperAttributeFacade().getDocumentation(indent);
     }
 
     /**
      * This method returns the documentation for this model element, with the lines wrapped after
      * the specified number of characters, values of less than 1 will indicate no line wrapping is
      * required. By default paragraphs are returned as HTML.
      * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>.
      * @see ModelElementFacade#getDocumentation(String indent, int lineLength)
      */
     public String getDocumentation(String indent, int lineLength)
     {
         return this.getSuperAttributeFacade().getDocumentation(indent, lineLength);
     }
 
     /**
      * This method returns the documentation for this model element, with the lines wrapped after
      * the specified number of characters, values of less than 1 will indicate no line wrapping is
      * required. HTML style determines if HTML Escaping is applied.
      * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle)
      */
     public String getDocumentation(String indent, int lineLength, boolean htmlStyle)
     {
         return this.getSuperAttributeFacade().getDocumentation(indent, lineLength, htmlStyle);
     }
 
     /**
      * The fully qualified name of this model element.
      * @see ModelElementFacade#getFullyQualifiedName()
      */
     public String getFullyQualifiedName()
     {
         return this.getSuperAttributeFacade().getFullyQualifiedName();
     }
 
     /**
      * Returns the fully qualified name of the model element. The fully qualified name includes
      * complete package qualified name of the underlying model element.  If modelName is true, then
      * the original name of the model element (the name contained within the model) will be the name
      * returned, otherwise a name from a language mapping will be returned.
      * @see ModelElementFacade#getFullyQualifiedName(boolean modelName)
      */
     public String getFullyQualifiedName(boolean modelName)
     {
         return this.getSuperAttributeFacade().getFullyQualifiedName(modelName);
     }
 
     /**
      * Returns the fully qualified name as a path, the returned value always starts with out a slash
      * '/'.
      * @see ModelElementFacade#getFullyQualifiedNamePath()
      */
     public String getFullyQualifiedNamePath()
     {
         return this.getSuperAttributeFacade().getFullyQualifiedNamePath();
     }
 
     /**
      * Gets the unique identifier of the underlying model element.
      * @see ModelElementFacade#getId()
      */
     public String getId()
     {
         return this.getSuperAttributeFacade().getId();
     }
 
     /**
      * UML2: Retrieves the keywords for this element. Used to modify implementation properties which
      * are not represented by other properties, i.e. native, transient, volatile, synchronized,
      * (added annotations) override, deprecated. Can also be used to suppress compiler warnings:
      * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require
      * JDK5 compiler level.
      * @see ModelElementFacade#getKeywords()
      */
     public Collection<String> getKeywords()
     {
         return this.getSuperAttributeFacade().getKeywords();
     }
 
     /**
      * UML2: Retrieves a localized label for this named element.
      * @see ModelElementFacade#getLabel()
      */
     public String getLabel()
     {
         return this.getSuperAttributeFacade().getLabel();
     }
 
     /**
      * The language mappings that have been set for this model element.
      * @see ModelElementFacade#getLanguageMappings()
      */
     public TypeMappings getLanguageMappings()
     {
         return this.getSuperAttributeFacade().getLanguageMappings();
     }
 
     /**
      * Return the model containing this model element (multiple models may be loaded and processed
      * at the same time).
      * @see ModelElementFacade#getModel()
      */
     public ModelFacade getModel()
     {
         return this.getSuperAttributeFacade().getModel();
     }
 
     /**
      * The name of the model element.
      * @see ModelElementFacade#getName()
      */
     public String getName()
     {
         return this.getSuperAttributeFacade().getName();
     }
 
     /**
      * Gets the package to which this model element belongs.
      * @see ModelElementFacade#getPackage()
      */
     public ModelElementFacade getPackage()
     {
         return this.getSuperAttributeFacade().getPackage();
     }
 
     /**
      * The name of this model element's package.
      * @see ModelElementFacade#getPackageName()
      */
     public String getPackageName()
     {
         return this.getSuperAttributeFacade().getPackageName();
     }
 
     /**
      * Gets the package name (optionally providing the ability to retrieve the model name and not
      * the mapped name).
      * @see ModelElementFacade#getPackageName(boolean modelName)
      */
     public String getPackageName(boolean modelName)
     {
         return this.getSuperAttributeFacade().getPackageName(modelName);
     }
 
     /**
      * Returns the package as a path, the returned value always starts with out a slash '/'.
      * @see ModelElementFacade#getPackagePath()
      */
     public String getPackagePath()
     {
         return this.getSuperAttributeFacade().getPackagePath();
     }
 
     /**
      * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the
      * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from
      * the names of the containing namespaces starting at the root of the hierarchy and ending with
      * the name of the NamedElement itself.
      * @see ModelElementFacade#getQualifiedName()
      */
     public String getQualifiedName()
     {
         return this.getSuperAttributeFacade().getQualifiedName();
     }
 
     /**
      * Gets the root package for the model element.
      * @see ModelElementFacade#getRootPackage()
      */
     public PackageFacade getRootPackage()
     {
         return this.getSuperAttributeFacade().getRootPackage();
     }
 
     /**
      * Gets the dependencies for which this model element is the source.
      * @see ModelElementFacade#getSourceDependencies()
      */
     public Collection<DependencyFacade> getSourceDependencies()
     {
         return this.getSuperAttributeFacade().getSourceDependencies();
     }
 
     /**
      * If this model element is the context of an activity graph, this represents that activity
      * graph.
      * @see ModelElementFacade#getStateMachineContext()
      */
     public StateMachineFacade getStateMachineContext()
     {
         return this.getSuperAttributeFacade().getStateMachineContext();
     }
 
     /**
      * The collection of ALL stereotype names for this model element.
      * @see ModelElementFacade#getStereotypeNames()
      */
     public Collection<String> getStereotypeNames()
     {
         return this.getSuperAttributeFacade().getStereotypeNames();
     }
 
     /**
      * Gets all stereotypes for this model element.
      * @see ModelElementFacade#getStereotypes()
      */
     public Collection<StereotypeFacade> getStereotypes()
     {
         return this.getSuperAttributeFacade().getStereotypes();
     }
 
     /**
      * Return the TaggedValues associated with this model element, under all stereotypes.
      * @see ModelElementFacade#getTaggedValues()
      */
     public Collection<TaggedValueFacade> getTaggedValues()
     {
         return this.getSuperAttributeFacade().getTaggedValues();
     }
 
     /**
      * Gets the dependencies for which this model element is the target.
      * @see ModelElementFacade#getTargetDependencies()
      */
     public Collection<DependencyFacade> getTargetDependencies()
     {
         return this.getSuperAttributeFacade().getTargetDependencies();
     }
 
     /**
      * Get the template parameter for this model element having the parameterName
      * @see ModelElementFacade#getTemplateParameter(String parameterName)
      */
     public Object getTemplateParameter(String parameterName)
     {
         return this.getSuperAttributeFacade().getTemplateParameter(parameterName);
     }
 
     /**
      * Get the template parameters for this model element
      * @see ModelElementFacade#getTemplateParameters()
      */
     public Collection<TemplateParameterFacade> getTemplateParameters()
     {
         return this.getSuperAttributeFacade().getTemplateParameters();
     }
 
     /**
      * The visibility (i.e. public, private, protected or package) of the model element, will
      * attempt a lookup for these values in the language mappings (if any).
      * @see ModelElementFacade#getVisibility()
      */
     public String getVisibility()
     {
         return this.getSuperAttributeFacade().getVisibility();
     }
 
     /**
      * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance
      * is taken into account when searching for the stereotype), false otherwise.
      * @see ModelElementFacade#hasExactStereotype(String stereotypeName)
      */
     public boolean hasExactStereotype(String stereotypeName)
     {
         return this.getSuperAttributeFacade().hasExactStereotype(stereotypeName);
     }
 
     /**
      * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma,
      * pipe, semicolon, or << >>
      * @see ModelElementFacade#hasKeyword(String keywordName)
      */
     public boolean hasKeyword(String keywordName)
     {
         return this.getSuperAttributeFacade().hasKeyword(keywordName);
     }
 
     /**
      * Returns true if the model element has the specified stereotype.  If the stereotype itself
      * does not match, then a search will be made up the stereotype inheritance hierarchy, and if
      * one of the stereotype's ancestors has a matching name this method will return true, false
      * otherwise.
      * For example, if we have a certain stereotype called <<exception>> and a model element has a
      * stereotype called <<applicationException>> which extends <<exception>>, when calling this
      * method with 'stereotypeName' defined as 'exception' the method would return true since
      * <<applicationException>> inherits from <<exception>>.  If you want to check if the model
      * element has the exact stereotype, then use the method 'hasExactStereotype' instead.
      * @see ModelElementFacade#hasStereotype(String stereotypeName)
      */
     public boolean hasStereotype(String stereotypeName)
     {
         return this.getSuperAttributeFacade().hasStereotype(stereotypeName);
     }
 
     /**
      * True if there are target dependencies from this element that are instances of BindingFacade.
      * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies.
      * @see ModelElementFacade#isBindingDependenciesPresent()
      */
     public boolean isBindingDependenciesPresent()
     {
         return this.getSuperAttributeFacade().isBindingDependenciesPresent();
     }
 
     /**
      * Indicates if any constraints are present on this model element.
      * @see ModelElementFacade#isConstraintsPresent()
      */
     public boolean isConstraintsPresent()
     {
         return this.getSuperAttributeFacade().isConstraintsPresent();
     }
 
     /**
      * Indicates if any documentation is present on this model element.
      * @see ModelElementFacade#isDocumentationPresent()
      */
     public boolean isDocumentationPresent()
     {
         return this.getSuperAttributeFacade().isDocumentationPresent();
     }
 
     /**
      * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript.
      * @see ModelElementFacade#isReservedWord()
      */
     public boolean isReservedWord()
     {
         return this.getSuperAttributeFacade().isReservedWord();
     }
 
     /**
      * True is there are template parameters on this model element. For UML2, applies to Class,
      * Operation, Property, and Parameter.
      * @see ModelElementFacade#isTemplateParametersPresent()
      */
     public boolean isTemplateParametersPresent()
     {
         return this.getSuperAttributeFacade().isTemplateParametersPresent();
     }
 
     /**
      * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++,
      * JavaScript. Contains no spaces, special characters etc. Constraint always applied on
      * Enumerations and Interfaces, optionally applies on other model elements.
      * @see ModelElementFacade#isValidIdentifierName()
      */
     public boolean isValidIdentifierName()
     {
         return this.getSuperAttributeFacade().isValidIdentifierName();
     }
 
     /**
      * Searches for the constraint with the specified 'name' on this model element, and if found
      * translates it using the specified 'translation' from a translation library discovered by the
      * framework.
      * @see ModelElementFacade#translateConstraint(String name, String translation)
      */
     public String translateConstraint(String name, String translation)
     {
         return this.getSuperAttributeFacade().translateConstraint(name, translation);
     }
 
     /**
      * Translates all constraints belonging to this model element with the given 'translation'.
      * @see ModelElementFacade#translateConstraints(String translation)
      */
     public String[] translateConstraints(String translation)
     {
         return this.getSuperAttributeFacade().translateConstraints(translation);
     }
 
     /**
      * Translates the constraints of the specified 'kind' belonging to this model element.
      * @see ModelElementFacade#translateConstraints(String kind, String translation)
      */
     public String[] translateConstraints(String kind, String translation)
     {
         return this.getSuperAttributeFacade().translateConstraints(kind, translation);
     }
 
     /**
      * @see MetafacadeBase#initialize()
      */
     @Override
     public void initialize()
     {
         this.getSuperAttributeFacade().initialize();
     }
 
     /**
      * @return Object getSuperAttributeFacade().getValidationOwner()
      * @see MetafacadeBase#getValidationOwner()
      */
     @Override
     public Object getValidationOwner()
     {
         Object owner = this.getSuperAttributeFacade().getValidationOwner();
         return owner;
     }
 
     /**
      * @return String getSuperAttributeFacade().getValidationName()
      * @see MetafacadeBase#getValidationName()
      */
     @Override
     public String getValidationName()
     {
         String name = this.getSuperAttributeFacade().getValidationName();
         return name;
     }
 
     /**
      * <p><b>Constraint:</b> org::andromda::cartridges::bpm4struts::metafacades::StrutsManageableEntityAttribute::SAFE NAME - TO BE REMOVED LATER</p>
      * <p><b>Error:</b> The names you give to fields cannot start with a lowercase character directly followed by a character in uppercase. This is due to a bug in the Jakarta commons library which is used by Struts. The behavior of that library is inconsistent with the reflection API provided by the JDK. Please rename this field or you'll get exceptions when running your web application.</p>
      * <p><b>OCL:</b> context StrutsAttribute inv: safeNamePresent</p>
      * @param validationMessages Collection<ModelValidationMessage>
      * @see MetafacadeBase#validateInvariants(Collection validationMessages)
      */
     @Override
     public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
     {
         this.getSuperAttributeFacade().validateInvariants(validationMessages);
         try
         {
             final Object contextElement = this.THIS();
             boolean constraintValid = OCLResultEnsurer.ensure(OCLIntrospector.invoke(contextElement,"safeNamePresent"));
             if (!constraintValid)
             {
                 validationMessages.add(
                     new ModelValidationMessage(
                         (MetafacadeBase)contextElement ,
                         "org::andromda::cartridges::bpm4struts::metafacades::StrutsManageableEntityAttribute::SAFE NAME - TO BE REMOVED LATER",
                         "The names you give to fields cannot start with a lowercase character directly followed by a character in uppercase. This is due to a bug in the Jakarta commons library which is used by Struts. The behavior of that library is inconsistent with the reflection API provided by the JDK. Please rename this field or you'll get exceptions when running your web application."));
             }
         }
         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::cartridges::bpm4struts::metafacades::StrutsManageableEntityAttribute::SAFE NAME - TO BE REMOVED LATER' ON "
                 + this.THIS().toString() + ": " + th.getMessage(), th);
         }
     }
 
     /**
      * The property that stores the name of the metafacade.
      */
     private static final String NAME_PROPERTY = "name";
     private static final String FQNAME_PROPERTY = "fullyQualifiedName";
 
     /**
      * @see Object#toString()
      */
     @Override
     public String toString()
     {
         final StringBuilder toString = new StringBuilder(this.getClass().getName());
         toString.append("[");
         try
         {
             toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY));
         }
         catch (final Throwable tryAgain)
         {
             try
             {
                 toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY));
             }
             catch (final Throwable ignore)
             {
                 // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property
             }
         }
         toString.append("]");
         return toString.toString();
     }
 }