// 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.ClassifierFacade;
import org.andromda.metafacades.uml.EventFacade;
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.Parameter;

/**
 * Specification of an argument used to pass information into or out of an invocation of a
 * behavioral feature. Parameters are allowed to be treated as connectable elements. Parameters have
 * support for streaming, exceptions, and parameter sets.
 * MetafacadeLogic for ParameterFacade
 *
 * @see ParameterFacade
 */
public abstract class ParameterFacadeLogic
    extends ModelElementFacadeLogicImpl
    implements ParameterFacade
{
    /**
     * The underlying UML object
     * @see Parameter
     */
    protected Parameter metaObject;

    /** Create Metafacade implementation instance using the MetafacadeFactory from the context
     * @param metaObjectIn
     * @param context
     */
    protected ParameterFacadeLogic(Parameter metaObjectIn, String context)
    {
        super(metaObjectIn, getContext(context));
        this.metaObject = metaObjectIn;
    }

    /**
     * The logger instance.
     */
    private static final Logger logger = Logger.getLogger(ParameterFacadeLogic.class);

    /**
     * Gets the context for this metafacade logic instance.
     * @param context String. Set to ParameterFacade if null
     * @return context String
     */
    private static String getContext(String context)
    {
        if (context == null)
        {
            context = "org.andromda.metafacades.uml.ParameterFacade";
        }
        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 ParameterFacade
     */
    public boolean isParameterFacadeMetaType()
    {
        return true;
    }

    // --------------- attributes ---------------------

   /**
    * @see ParameterFacade#getDefaultValue()
    * @return String
    */
    protected abstract String handleGetDefaultValue();

    private String __defaultValue1a;
    private boolean __defaultValue1aSet = false;

    /**
     * TODO: Model Documentation for ParameterFacade.defaultValue
     * @return (String)handleGetDefaultValue()
     */
    public final String getDefaultValue()
    {
        String defaultValue1a = this.__defaultValue1a;
        if (!this.__defaultValue1aSet)
        {
            // defaultValue has no pre constraints
            defaultValue1a = handleGetDefaultValue();
            // defaultValue has no post constraints
            this.__defaultValue1a = defaultValue1a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__defaultValue1aSet = true;
            }
        }
        return defaultValue1a;
    }

   /**
    * @see ParameterFacade#isDefaultValuePresent()
    * @return boolean
    */
    protected abstract boolean handleIsDefaultValuePresent();

    private boolean __defaultValuePresent2a;
    private boolean __defaultValuePresent2aSet = false;

    /**
     * Indicates if the default value is present.
     * @return (boolean)handleIsDefaultValuePresent()
     */
    public final boolean isDefaultValuePresent()
    {
        boolean defaultValuePresent2a = this.__defaultValuePresent2a;
        if (!this.__defaultValuePresent2aSet)
        {
            // defaultValuePresent has no pre constraints
            defaultValuePresent2a = handleIsDefaultValuePresent();
            // defaultValuePresent has no post constraints
            this.__defaultValuePresent2a = defaultValuePresent2a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__defaultValuePresent2aSet = true;
            }
        }
        return defaultValuePresent2a;
    }

   /**
    * @see ParameterFacade#getGetterName()
    * @return String
    */
    protected abstract String handleGetGetterName();

    private String __getterName3a;
    private boolean __getterName3aSet = false;

    /**
     * The name to use for accessors getting this parameter from a bean.
     * @return (String)handleGetGetterName()
     */
    public final String getGetterName()
    {
        String getterName3a = this.__getterName3a;
        if (!this.__getterName3aSet)
        {
            // getterName has no pre constraints
            getterName3a = handleGetGetterName();
            // getterName has no post constraints
            this.__getterName3a = getterName3a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__getterName3aSet = true;
            }
        }
        return getterName3a;
    }

   /**
    * @see ParameterFacade#getGetterSetterTypeName()
    * @return String
    */
    protected abstract String handleGetGetterSetterTypeName();

    private String __getterSetterTypeName4a;
    private boolean __getterSetterTypeName4aSet = false;

    /**
     * Fully Qualified TypeName, determined in part by multiplicity (for UML2). For UML14, same as
     * getterName.
     * @return (String)handleGetGetterSetterTypeName()
     */
    public final String getGetterSetterTypeName()
    {
        String getterSetterTypeName4a = this.__getterSetterTypeName4a;
        if (!this.__getterSetterTypeName4aSet)
        {
            // getterSetterTypeName has no pre constraints
            getterSetterTypeName4a = handleGetGetterSetterTypeName();
            // getterSetterTypeName has no post constraints
            this.__getterSetterTypeName4a = getterSetterTypeName4a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__getterSetterTypeName4aSet = true;
            }
        }
        return getterSetterTypeName4a;
    }

   /**
    * @see ParameterFacade#getGetterSetterTypeNameImpl()
    * @return String
    */
    protected abstract String handleGetGetterSetterTypeNameImpl();

    private String __getterSetterTypeNameImpl5a;
    private boolean __getterSetterTypeNameImpl5aSet = false;

    /**
     * Fully Qualified implementation class of TypeName, determined in part by multiplicity (for
     * UML2). If upper multiplicity =1, same as getterSetterTypeName.
     * @return (String)handleGetGetterSetterTypeNameImpl()
     */
    public final String getGetterSetterTypeNameImpl()
    {
        String getterSetterTypeNameImpl5a = this.__getterSetterTypeNameImpl5a;
        if (!this.__getterSetterTypeNameImpl5aSet)
        {
            // getterSetterTypeNameImpl has no pre constraints
            getterSetterTypeNameImpl5a = handleGetGetterSetterTypeNameImpl();
            // getterSetterTypeNameImpl has no post constraints
            this.__getterSetterTypeNameImpl5a = getterSetterTypeNameImpl5a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__getterSetterTypeNameImpl5aSet = true;
            }
        }
        return getterSetterTypeNameImpl5a;
    }

   /**
    * @see ParameterFacade#isRequired()
    * @return boolean
    */
    protected abstract boolean handleIsRequired();

    private boolean __required6a;
    private boolean __required6aSet = false;

    /**
     * Whether or not this parameter is considered required (i.e must a non-empty value).
     * @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 ParameterFacade#isReturn()
    * @return boolean
    */
    protected abstract boolean handleIsReturn();

    private boolean __return7a;
    private boolean __return7aSet = false;

    /**
     * Whether or not this parameter represents a return parameter.
     * @return (boolean)handleIsReturn()
     */
    public final boolean isReturn()
    {
        boolean return7a = this.__return7a;
        if (!this.__return7aSet)
        {
            // return has no pre constraints
            return7a = handleIsReturn();
            // return has no post constraints
            this.__return7a = return7a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__return7aSet = true;
            }
        }
        return return7a;
    }

   /**
    * @see ParameterFacade#getSetterName()
    * @return String
    */
    protected abstract String handleGetSetterName();

    private String __setterName8a;
    private boolean __setterName8aSet = false;

    /**
     * The name to use for accessors getting this parameter in a bean.
     * @return (String)handleGetSetterName()
     */
    public final String getSetterName()
    {
        String setterName8a = this.__setterName8a;
        if (!this.__setterName8aSet)
        {
            // setterName has no pre constraints
            setterName8a = handleGetSetterName();
            // setterName has no post constraints
            this.__setterName8a = setterName8a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__setterName8aSet = true;
            }
        }
        return setterName8a;
    }

   /**
    * @see ParameterFacade#isReadable()
    * @return boolean
    */
    protected abstract boolean handleIsReadable();

    private boolean __readable9a;
    private boolean __readable9aSet = false;

    /**
     * True if this parameter is readable, aka an in-parameter, or this feature is unspecified.
     * @return (boolean)handleIsReadable()
     */
    public final boolean isReadable()
    {
        boolean readable9a = this.__readable9a;
        if (!this.__readable9aSet)
        {
            // readable has no pre constraints
            readable9a = handleIsReadable();
            // readable has no post constraints
            this.__readable9a = readable9a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__readable9aSet = true;
            }
        }
        return readable9a;
    }

   /**
    * @see ParameterFacade#isWritable()
    * @return boolean
    */
    protected abstract boolean handleIsWritable();

    private boolean __writable10a;
    private boolean __writable10aSet = false;

    /**
     * True if this parameter is writable, aka an out-parameter, or this feature is unspecified.
     * @return (boolean)handleIsWritable()
     */
    public final boolean isWritable()
    {
        boolean writable10a = this.__writable10a;
        if (!this.__writable10aSet)
        {
            // writable has no pre constraints
            writable10a = handleIsWritable();
            // writable has no post constraints
            this.__writable10a = writable10a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__writable10aSet = true;
            }
        }
        return writable10a;
    }

   /**
    * @see ParameterFacade#isInParameter()
    * @return boolean
    */
    protected abstract boolean handleIsInParameter();

    private boolean __inParameter11a;
    private boolean __inParameter11aSet = false;

    /**
     * True if this parameter is an 'in' parameter.
     * @return (boolean)handleIsInParameter()
     */
    public final boolean isInParameter()
    {
        boolean inParameter11a = this.__inParameter11a;
        if (!this.__inParameter11aSet)
        {
            // inParameter has no pre constraints
            inParameter11a = handleIsInParameter();
            // inParameter has no post constraints
            this.__inParameter11a = inParameter11a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__inParameter11aSet = true;
            }
        }
        return inParameter11a;
    }

   /**
    * @see ParameterFacade#isOutParameter()
    * @return boolean
    */
    protected abstract boolean handleIsOutParameter();

    private boolean __outParameter12a;
    private boolean __outParameter12aSet = false;

    /**
     * True if this parameter is an 'out' parameter.
     * @return (boolean)handleIsOutParameter()
     */
    public final boolean isOutParameter()
    {
        boolean outParameter12a = this.__outParameter12a;
        if (!this.__outParameter12aSet)
        {
            // outParameter has no pre constraints
            outParameter12a = handleIsOutParameter();
            // outParameter has no post constraints
            this.__outParameter12a = outParameter12a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__outParameter12aSet = true;
            }
        }
        return outParameter12a;
    }

   /**
    * @see ParameterFacade#isInoutParameter()
    * @return boolean
    */
    protected abstract boolean handleIsInoutParameter();

    private boolean __inoutParameter13a;
    private boolean __inoutParameter13aSet = false;

    /**
     * True if this parameter is an inout parameter.
     * @return (boolean)handleIsInoutParameter()
     */
    public final boolean isInoutParameter()
    {
        boolean inoutParameter13a = this.__inoutParameter13a;
        if (!this.__inoutParameter13aSet)
        {
            // inoutParameter has no pre constraints
            inoutParameter13a = handleIsInoutParameter();
            // inoutParameter has no post constraints
            this.__inoutParameter13a = inoutParameter13a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__inoutParameter13aSet = true;
            }
        }
        return inoutParameter13a;
    }

   /**
    * @see ParameterFacade#getUpper()
    * @return int
    */
    protected abstract int handleGetUpper();

    private int __upper14a;
    private boolean __upper14aSet = false;

    /**
     * the upper value of the multiplicity (will be -1 for *)
     * -only applicable for UML2
     * @return (int)handleGetUpper()
     */
    public final int getUpper()
    {
        int upper14a = this.__upper14a;
        if (!this.__upper14aSet)
        {
            // upper has no pre constraints
            upper14a = handleGetUpper();
            // upper has no post constraints
            this.__upper14a = upper14a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__upper14aSet = true;
            }
        }
        return upper14a;
    }

   /**
    * @see ParameterFacade#getLower()
    * @return int
    */
    protected abstract int handleGetLower();

    private int __lower15a;
    private boolean __lower15aSet = false;

    /**
     * the lower value for the multiplicity
     * -only applicable for UML2
     * @return (int)handleGetLower()
     */
    public final int getLower()
    {
        int lower15a = this.__lower15a;
        if (!this.__lower15aSet)
        {
            // lower has no pre constraints
            lower15a = handleGetLower();
            // lower has no post constraints
            this.__lower15a = lower15a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__lower15aSet = true;
            }
        }
        return lower15a;
    }

   /**
    * @see ParameterFacade#isUnique()
    * @return boolean
    */
    protected abstract boolean handleIsUnique();

    private boolean __unique16a;
    private boolean __unique16aSet = false;

    /**
     * If Parameter type isMany (UML2), is the parameter unique within the Collection. Unique+Sorted
     * determines pareter implementation type. For UML14, always false.
     * @return (boolean)handleIsUnique()
     */
    public final boolean isUnique()
    {
        boolean unique16a = this.__unique16a;
        if (!this.__unique16aSet)
        {
            // unique has no pre constraints
            unique16a = handleIsUnique();
            // unique has no post constraints
            this.__unique16a = unique16a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__unique16aSet = true;
            }
        }
        return unique16a;
    }

   /**
    * @see ParameterFacade#isOrdered()
    * @return boolean
    */
    protected abstract boolean handleIsOrdered();

    private boolean __ordered17a;
    private boolean __ordered17aSet = false;

    /**
     * UML2 Only: Is parameter ordered within the Collection type. Ordered+Unique determines the
     * implementation Collection Type. For UML14, always false.
     * @return (boolean)handleIsOrdered()
     */
    public final boolean isOrdered()
    {
        boolean ordered17a = this.__ordered17a;
        if (!this.__ordered17aSet)
        {
            // ordered has no pre constraints
            ordered17a = handleIsOrdered();
            // ordered has no post constraints
            this.__ordered17a = ordered17a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__ordered17aSet = true;
            }
        }
        return ordered17a;
    }

   /**
    * @see ParameterFacade#isMany()
    * @return boolean
    */
    protected abstract boolean handleIsMany();

    private boolean __many18a;
    private boolean __many18aSet = false;

    /**
     * If upper>1 or upper==unlimited. Only applies to UML2. For UML14, always false.
     * @return (boolean)handleIsMany()
     */
    public final boolean isMany()
    {
        boolean many18a = this.__many18a;
        if (!this.__many18aSet)
        {
            // many has no pre constraints
            many18a = handleIsMany();
            // many has no post constraints
            this.__many18a = many18a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__many18aSet = true;
            }
        }
        return many18a;
    }

   /**
    * @see ParameterFacade#isException()
    * @return boolean
    */
    protected abstract boolean handleIsException();

    private boolean __exception19a;
    private boolean __exception19aSet = false;

    /**
     * UML2: Returns the value of the 'Is Exception' attribute. The default value is "false". Tells
     * whether an output parameter may emit a value to the exclusion of the other outputs.
     * @return (boolean)handleIsException()
     */
    public final boolean isException()
    {
        boolean exception19a = this.__exception19a;
        if (!this.__exception19aSet)
        {
            // exception has no pre constraints
            exception19a = handleIsException();
            // exception has no post constraints
            this.__exception19a = exception19a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__exception19aSet = true;
            }
        }
        return exception19a;
    }

   /**
    * @see ParameterFacade#getEffect()
    * @return String
    */
    protected abstract String handleGetEffect();

    private String __effect20a;
    private boolean __effect20aSet = false;

    /**
     * UML2: A representation of the literals of the enumeration 'Parameter Effect Kind': CREATE,
     * READ, UPDATE, DELETE. The datatype ParameterEffectKind is an enumeration that indicates the
     * effect of a behavior on values passed in or out of its parameters.
     * @return (String)handleGetEffect()
     */
    public final String getEffect()
    {
        String effect20a = this.__effect20a;
        if (!this.__effect20aSet)
        {
            // effect has no pre constraints
            effect20a = handleGetEffect();
            // effect has no post constraints
            this.__effect20a = effect20a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__effect20aSet = true;
            }
        }
        return effect20a;
    }

    // ------------- associations ------------------

    /**
     * Specification of an argument used to pass information into or out of an invocation of a
     * behavioral
     * feature. Parameters are allowed to be treated as connectable elements. Parameters have
     * support for
     * streaming, exceptions, and parameter sets.
     * @return (ClassifierFacade)handleGetType()
     */
    public final ClassifierFacade getType()
    {
        ClassifierFacade getType1r = null;
        // parameterFacade 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
            ParameterFacadeLogic.logger.warn("incorrect metafacade cast for ParameterFacadeLogic.getType ClassifierFacade " + result + ": " + shieldedResult);
        }
        // parameterFacade has no post constraints
        return getType1r;
    }

    /**
     * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
     * @return Object
     */
    protected abstract Object handleGetType();

    /**
     * The parameters to this event.
     * @return (EventFacade)handleGetEvent()
     */
    public final EventFacade getEvent()
    {
        EventFacade getEvent2r = null;
        // parameters has no pre constraints
        Object result = handleGetEvent();
        MetafacadeBase shieldedResult = this.shieldedElement(result);
        try
        {
            getEvent2r = (EventFacade)shieldedResult;
        }
        catch (ClassCastException ex)
        {
            // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
            ParameterFacadeLogic.logger.warn("incorrect metafacade cast for ParameterFacadeLogic.getEvent EventFacade " + result + ": " + shieldedResult);
        }
        // parameters has no post constraints
        return getEvent2r;
    }

    /**
     * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
     * @return Object
     */
    protected abstract Object handleGetEvent();

    /**
     * Return all parameters for the operation, including the return parameter.
     * @return (OperationFacade)handleGetOperation()
     */
    public final OperationFacade getOperation()
    {
        OperationFacade getOperation3r = null;
        // parameters has no pre constraints
        Object result = handleGetOperation();
        MetafacadeBase shieldedResult = this.shieldedElement(result);
        try
        {
            getOperation3r = (OperationFacade)shieldedResult;
        }
        catch (ClassCastException ex)
        {
            // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
            ParameterFacadeLogic.logger.warn("incorrect metafacade cast for ParameterFacadeLogic.getOperation OperationFacade " + result + ": " + shieldedResult);
        }
        // parameters has no post constraints
        return getOperation3r;
    }

    /**
     * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
     * @return Object
     */
    protected abstract Object handleGetOperation();

    /**
     * <p><b>Constraint:</b> org::andromda::metafacades::uml::ParameterFacade::parameter needs a type</p>
     * <p><b>Error:</b> Each parameter needs a type, you cannot leave the type unspecified.</p>
     * <p><b>OCL:</b> context ParameterFacade
inv: return = false implies type.name->notEmpty()</p>
     * <p><b>Constraint:</b> org::andromda::metafacades::uml::ParameterFacade::non return type parameters must be named</p>
     * <p><b>Error:</b> Each parameter that is NOT a return parameter must have a non-empty name.</p>
     * <p><b>OCL:</b> context ParameterFacade
inv: return = false 
implies name -> notEmpty()</p>
     * <p><b>Constraint:</b> org::andromda::metafacades::uml::ParameterFacade::primitive parameter cannot be used in Collection</p>
     * <p><b>Error:</b> Primitive parameters cannot be used in Collections (multiplicity > 1). Use the wrapped type instead.</p>
     * <p><b>OCL:</b> context ParameterFacade inv: type.primitive implies (many = false)</p>
     * <p><b>Constraint:</b> org::andromda::metafacades::uml::ParameterFacade::primitive parameter must be required</p>
     * <p><b>Error:</b> Primitive operation parameters must have a multiplicity lower bound > 0 (must be required). Use a wrapped type, or change the multiplicity.</p>
     * <p><b>OCL:</b> context ParameterFacade inv: type.primitive implies (lower > 0)</p>
     * <p><b>Constraint:</b> org::andromda::metafacades::uml::ParameterFacade::wrapped primitive parameter should not be required</p>
     * <p><b>Error:</b> Wrapped primitive operation parameters must have a multiplicity lower bound = 0 (must be optional). Use the unwrapped type, or change the multiplicity.</p>
     * <p><b>OCL:</b> context ParameterFacade 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((Boolean.valueOf(String.valueOf(OCLExpressions.equal(OCLIntrospector.invoke(contextElement,"return"),false))).booleanValue()?OCLCollections.notEmpty(OCLIntrospector.invoke(contextElement,"type.name")):true));
            if (!constraintValid)
            {
                validationMessages.add(
                    new ModelValidationMessage(
                        (MetafacadeBase)contextElement ,
                        "org::andromda::metafacades::uml::ParameterFacade::parameter needs a type",
                        "Each parameter 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::ParameterFacade::parameter needs a type' ON "
                + this.THIS().toString() + ": " + th.getMessage(), th);
        }
        try
        {
            final Object contextElement = this.THIS();
            boolean constraintValid = OCLResultEnsurer.ensure((Boolean.valueOf(String.valueOf(OCLExpressions.equal(OCLIntrospector.invoke(contextElement,"return"),false))).booleanValue()?OCLCollections.notEmpty(OCLIntrospector.invoke(contextElement,"name")):true));
            if (!constraintValid)
            {
                validationMessages.add(
                    new ModelValidationMessage(
                        (MetafacadeBase)contextElement ,
                        "org::andromda::metafacades::uml::ParameterFacade::non return type parameters must be named",
                        "Each parameter that is NOT a return parameter 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::ParameterFacade::non return type parameters must be named' 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::ParameterFacade::primitive parameter cannot be used in Collection",
                        "Primitive parameters 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::ParameterFacade::primitive parameter 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(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::ParameterFacade::primitive parameter must be required",
                        "Primitive operation parameters 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::ParameterFacade::primitive parameter must be required' 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::ParameterFacade::wrapped primitive parameter should not be required",
                        "Wrapped primitive operation parameters 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::ParameterFacade::wrapped primitive parameter should not be required' ON "
                + this.THIS().toString() + ": " + th.getMessage(), th);
        }
    }
}