// license-header java merge-point
//
// Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
//
package org.andromda.metafacades.uml14;

import java.util.Collection;
import java.util.List;
import org.andromda.core.metafacade.MetafacadeBase;
import org.andromda.core.metafacade.ModelValidationMessage;
import org.andromda.metafacades.uml.ActorFacade;
import org.andromda.metafacades.uml.ManageableEntity;
import org.andromda.metafacades.uml.ManageableEntityAssociationEnd;
import org.andromda.metafacades.uml.ManageableEntityAttribute;
import org.andromda.metafacades.uml.ModelElementFacade;
import org.apache.log4j.Logger;

/**
 * An Entity that is Manageable: will produce CRUD operations in the EntityManager implementation.
 * MetafacadeLogic for ManageableEntity
 *
 * @see ManageableEntity
 */
public abstract class ManageableEntityLogic
    extends EntityLogicImpl
    implements ManageableEntity
{
    /**
     * The underlying UML object
     * @see Object
     */
    protected Object metaObject;

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

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

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

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

   /**
    * @see ManageableEntity#getManageablePackageName()
    * @return String
    */
    protected abstract String handleGetManageablePackageName();

    private String __manageablePackageName1a;
    private boolean __manageablePackageName1aSet = false;

    /**
     * The entity package name.
     * @return (String)handleGetManageablePackageName()
     */
    public final String getManageablePackageName()
    {
        String manageablePackageName1a = this.__manageablePackageName1a;
        if (!this.__manageablePackageName1aSet)
        {
            // manageablePackageName has no pre constraints
            manageablePackageName1a = handleGetManageablePackageName();
            // manageablePackageName has no post constraints
            this.__manageablePackageName1a = manageablePackageName1a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__manageablePackageName1aSet = true;
            }
        }
        return manageablePackageName1a;
    }

   /**
    * @see ManageableEntity#getManageableServiceAccessorCall()
    * @return String
    */
    protected abstract String handleGetManageableServiceAccessorCall();

    private String __manageableServiceAccessorCall2a;
    private boolean __manageableServiceAccessorCall2aSet = false;

    /**
     * The entity accessor (getter) call.
     * @return (String)handleGetManageableServiceAccessorCall()
     */
    public final String getManageableServiceAccessorCall()
    {
        String manageableServiceAccessorCall2a = this.__manageableServiceAccessorCall2a;
        if (!this.__manageableServiceAccessorCall2aSet)
        {
            // manageableServiceAccessorCall has no pre constraints
            manageableServiceAccessorCall2a = handleGetManageableServiceAccessorCall();
            // manageableServiceAccessorCall has no post constraints
            this.__manageableServiceAccessorCall2a = manageableServiceAccessorCall2a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__manageableServiceAccessorCall2aSet = true;
            }
        }
        return manageableServiceAccessorCall2a;
    }

   /**
    * @see ManageableEntity#isRead()
    * @return boolean
    */
    protected abstract boolean handleIsRead();

    private boolean __read3a;
    private boolean __read3aSet = false;

    /**
     * Create a read operation on the entity manager?
     * @return (boolean)handleIsRead()
     */
    public final boolean isRead()
    {
        boolean read3a = this.__read3a;
        if (!this.__read3aSet)
        {
            // read has no pre constraints
            read3a = handleIsRead();
            // read has no post constraints
            this.__read3a = read3a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__read3aSet = true;
            }
        }
        return read3a;
    }

   /**
    * @see ManageableEntity#isCreate()
    * @return boolean
    */
    protected abstract boolean handleIsCreate();

    private boolean __create4a;
    private boolean __create4aSet = false;

    /**
     * Create a create operation on the entity manager?
     * @return (boolean)handleIsCreate()
     */
    public final boolean isCreate()
    {
        boolean create4a = this.__create4a;
        if (!this.__create4aSet)
        {
            // create has no pre constraints
            create4a = handleIsCreate();
            // create has no post constraints
            this.__create4a = create4a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__create4aSet = true;
            }
        }
        return create4a;
    }

   /**
    * @see ManageableEntity#isUpdate()
    * @return boolean
    */
    protected abstract boolean handleIsUpdate();

    private boolean __update5a;
    private boolean __update5aSet = false;

    /**
     * Create an update operation on the entity manager?
     * @return (boolean)handleIsUpdate()
     */
    public final boolean isUpdate()
    {
        boolean update5a = this.__update5a;
        if (!this.__update5aSet)
        {
            // update has no pre constraints
            update5a = handleIsUpdate();
            // update has no post constraints
            this.__update5a = update5a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__update5aSet = true;
            }
        }
        return update5a;
    }

   /**
    * @see ManageableEntity#isDelete()
    * @return boolean
    */
    protected abstract boolean handleIsDelete();

    private boolean __delete6a;
    private boolean __delete6aSet = false;

    /**
     * Create a delete operation on the entity manager?
     * @return (boolean)handleIsDelete()
     */
    public final boolean isDelete()
    {
        boolean delete6a = this.__delete6a;
        if (!this.__delete6aSet)
        {
            // delete has no pre constraints
            delete6a = handleIsDelete();
            // delete has no post constraints
            this.__delete6a = delete6a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__delete6aSet = true;
            }
        }
        return delete6a;
    }

   /**
    * @see ManageableEntity#getManageablePackagePath()
    * @return String
    */
    protected abstract String handleGetManageablePackagePath();

    private String __manageablePackagePath7a;
    private boolean __manageablePackagePath7aSet = false;

    /**
     * The Package path of the Entity
     * @return (String)handleGetManageablePackagePath()
     */
    public final String getManageablePackagePath()
    {
        String manageablePackagePath7a = this.__manageablePackagePath7a;
        if (!this.__manageablePackagePath7aSet)
        {
            // manageablePackagePath has no pre constraints
            manageablePackagePath7a = handleGetManageablePackagePath();
            // manageablePackagePath has no post constraints
            this.__manageablePackagePath7a = manageablePackagePath7a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__manageablePackagePath7aSet = true;
            }
        }
        return manageablePackagePath7a;
    }

   /**
    * @see ManageableEntity#getManageableServiceName()
    * @return String
    */
    protected abstract String handleGetManageableServiceName();

    private String __manageableServiceName8a;
    private boolean __manageableServiceName8aSet = false;

    /**
     * The service name of the entity.
     * @return (String)handleGetManageableServiceName()
     */
    public final String getManageableServiceName()
    {
        String manageableServiceName8a = this.__manageableServiceName8a;
        if (!this.__manageableServiceName8aSet)
        {
            // manageableServiceName has no pre constraints
            manageableServiceName8a = handleGetManageableServiceName();
            // manageableServiceName has no post constraints
            this.__manageableServiceName8a = manageableServiceName8a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__manageableServiceName8aSet = true;
            }
        }
        return manageableServiceName8a;
    }

   /**
    * @see ManageableEntity#getFullyQualifiedManageableServiceName()
    * @return String
    */
    protected abstract String handleGetFullyQualifiedManageableServiceName();

    private String __fullyQualifiedManageableServiceName9a;
    private boolean __fullyQualifiedManageableServiceName9aSet = false;

    /**
     * The fully qualified service name of the entity.
     * @return (String)handleGetFullyQualifiedManageableServiceName()
     */
    public final String getFullyQualifiedManageableServiceName()
    {
        String fullyQualifiedManageableServiceName9a = this.__fullyQualifiedManageableServiceName9a;
        if (!this.__fullyQualifiedManageableServiceName9aSet)
        {
            // fullyQualifiedManageableServiceName has no pre constraints
            fullyQualifiedManageableServiceName9a = handleGetFullyQualifiedManageableServiceName();
            // fullyQualifiedManageableServiceName has no post constraints
            this.__fullyQualifiedManageableServiceName9a = fullyQualifiedManageableServiceName9a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__fullyQualifiedManageableServiceName9aSet = true;
            }
        }
        return fullyQualifiedManageableServiceName9a;
    }

   /**
    * @see ManageableEntity#getManageableServiceFullPath()
    * @return String
    */
    protected abstract String handleGetManageableServiceFullPath();

    private String __manageableServiceFullPath10a;
    private boolean __manageableServiceFullPath10aSet = false;

    /**
     * The service full path of the entity.
     * @return (String)handleGetManageableServiceFullPath()
     */
    public final String getManageableServiceFullPath()
    {
        String manageableServiceFullPath10a = this.__manageableServiceFullPath10a;
        if (!this.__manageableServiceFullPath10aSet)
        {
            // manageableServiceFullPath has no pre constraints
            manageableServiceFullPath10a = handleGetManageableServiceFullPath();
            // manageableServiceFullPath has no post constraints
            this.__manageableServiceFullPath10a = manageableServiceFullPath10a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__manageableServiceFullPath10aSet = true;
            }
        }
        return manageableServiceFullPath10a;
    }

   /**
    * @see ManageableEntity#getManageableMembers()
    * @return List<ModelElementFacade>
    */
    protected abstract List<ModelElementFacade> handleGetManageableMembers();

    private List<ModelElementFacade> __manageableMembers11a;
    private boolean __manageableMembers11aSet = false;

    /**
     * ManageableAttributes and ManageableAssociationEnds
     * @return (List<ModelElementFacade>)handleGetManageableMembers()
     */
    public final List<ModelElementFacade> getManageableMembers()
    {
        List<ModelElementFacade> manageableMembers11a = this.__manageableMembers11a;
        if (!this.__manageableMembers11aSet)
        {
            // manageableMembers has no pre constraints
            manageableMembers11a = handleGetManageableMembers();
            // manageableMembers has no post constraints
            this.__manageableMembers11a = manageableMembers11a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__manageableMembers11aSet = true;
            }
        }
        return manageableMembers11a;
    }

   /**
    * @see ManageableEntity#isManageable()
    * @return boolean
    */
    protected abstract boolean handleIsManageable();

    private boolean __manageable12a;
    private boolean __manageable12aSet = false;

    /**
     * True: Entity is manageable.
     * @return (boolean)handleIsManageable()
     */
    public final boolean isManageable()
    {
        boolean manageable12a = this.__manageable12a;
        if (!this.__manageable12aSet)
        {
            // manageable has no pre constraints
            manageable12a = handleIsManageable();
            // manageable has no post constraints
            this.__manageable12a = manageable12a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__manageable12aSet = true;
            }
        }
        return manageable12a;
    }

   /**
    * @see ManageableEntity#getMaximumListSize()
    * @return int
    */
    protected abstract int handleGetMaximumListSize();

    private int __maximumListSize13a;
    private boolean __maximumListSize13aSet = false;

    /**
     * The maximum number of rows to load from the database.
     * @return (int)handleGetMaximumListSize()
     */
    public final int getMaximumListSize()
    {
        int maximumListSize13a = this.__maximumListSize13a;
        if (!this.__maximumListSize13aSet)
        {
            // maximumListSize has no pre constraints
            maximumListSize13a = handleGetMaximumListSize();
            // maximumListSize has no post constraints
            this.__maximumListSize13a = maximumListSize13a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__maximumListSize13aSet = true;
            }
        }
        return maximumListSize13a;
    }

   /**
    * @see ManageableEntity#getPageSize()
    * @return int
    */
    protected abstract int handleGetPageSize();

    private int __pageSize14a;
    private boolean __pageSize14aSet = false;

    /**
     * The maximum number of rows to load from the database.
     * @return (int)handleGetPageSize()
     */
    public final int getPageSize()
    {
        int pageSize14a = this.__pageSize14a;
        if (!this.__pageSize14aSet)
        {
            // pageSize has no pre constraints
            pageSize14a = handleGetPageSize();
            // pageSize has no post constraints
            this.__pageSize14a = pageSize14a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__pageSize14aSet = true;
            }
        }
        return pageSize14a;
    }

   /**
    * @see ManageableEntity#isResolveable()
    * @return boolean
    */
    protected abstract boolean handleIsResolveable();

    private boolean __resolveable15a;
    private boolean __resolveable15aSet = false;

    /**
     * The maximum number of rows to load from the database.
     * @return (boolean)handleIsResolveable()
     */
    public final boolean isResolveable()
    {
        boolean resolveable15a = this.__resolveable15a;
        if (!this.__resolveable15aSet)
        {
            // resolveable has no pre constraints
            resolveable15a = handleIsResolveable();
            // resolveable has no post constraints
            this.__resolveable15a = resolveable15a;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__resolveable15aSet = true;
            }
        }
        return resolveable15a;
    }

    // ---------------- business methods ----------------------

    /**
     * Method to be implemented in descendants
     * Returns a string with the attributes without wrapper types.
     * @param withTypes
     * @return String
     */
    protected abstract String handleListManageableMembers(boolean withTypes);

    /**
     * Returns a string with the attributes without wrapper types.
     * @param withTypes boolean
     * TODO: Model Documentation for
     * ManageableEntity.listManageableMembers(withTypes)
     * @return handleListManageableMembers(withTypes)
     */
    public String listManageableMembers(boolean withTypes)
    {
        // listManageableMembers has no pre constraints
        String returnValue = handleListManageableMembers(withTypes);
        // listManageableMembers has no post constraints
        return returnValue;
    }

    /**
     * Method to be implemented in descendants
     * Returns a string with the attributes and wrapper types.
     * @return String
     */
    protected abstract String handleListManageableMembersWithWrapperTypes();

    /**
     * Returns a string with the attributes and wrapper types.
     * @return handleListManageableMembersWithWrapperTypes()
     */
    public String listManageableMembersWithWrapperTypes()
    {
        // listManageableMembersWithWrapperTypes has no pre constraints
        String returnValue = handleListManageableMembersWithWrapperTypes();
        // listManageableMembersWithWrapperTypes has no post constraints
        return returnValue;
    }

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

    private List<ActorFacade> __getUsers1r;
    private boolean __getUsers1rSet = false;

    /**
     * An Entity that is Manageable: will produce CRUD operations in the EntityManager
     * implementation.
     * @return (List<ActorFacade>)handleGetUsers()
     */
    public final List<ActorFacade> getUsers()
    {
        List<ActorFacade> getUsers1r = this.__getUsers1r;
        if (!this.__getUsers1rSet)
        {
            // manageableEntity has no pre constraints
            List result = handleGetUsers();
            List shieldedResult = this.shieldedElements(result);
            try
            {
                getUsers1r = (List<ActorFacade>)shieldedResult;
            }
            catch (ClassCastException ex)
            {
                // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
                ManageableEntityLogic.logger.warn("incorrect metafacade cast for ManageableEntityLogic.getUsers List<ActorFacade> " + result + ": " + shieldedResult);
            }
            // manageableEntity has no post constraints
            this.__getUsers1r = getUsers1r;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__getUsers1rSet = true;
            }
        }
        return getUsers1r;
    }

    /**
     * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
     * @return  List
     */
    protected abstract List handleGetUsers();

    private List<ManageableEntityAssociationEnd> __getManageableAssociationEnds2r;
    private boolean __getManageableAssociationEnds2rSet = false;

    /**
     * An Entity that is Manageable: will produce CRUD operations in the EntityManager
     * implementation.
     * @return (List<ManageableEntityAssociationEnd>)handleGetManageableAssociationEnds()
     */
    public final List<ManageableEntityAssociationEnd> getManageableAssociationEnds()
    {
        List<ManageableEntityAssociationEnd> getManageableAssociationEnds2r = this.__getManageableAssociationEnds2r;
        if (!this.__getManageableAssociationEnds2rSet)
        {
            // manageableEntity has no pre constraints
            List result = handleGetManageableAssociationEnds();
            List shieldedResult = this.shieldedElements(result);
            try
            {
                getManageableAssociationEnds2r = (List<ManageableEntityAssociationEnd>)shieldedResult;
            }
            catch (ClassCastException ex)
            {
                // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
                ManageableEntityLogic.logger.warn("incorrect metafacade cast for ManageableEntityLogic.getManageableAssociationEnds List<ManageableEntityAssociationEnd> " + result + ": " + shieldedResult);
            }
            // manageableEntity has no post constraints
            this.__getManageableAssociationEnds2r = getManageableAssociationEnds2r;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__getManageableAssociationEnds2rSet = true;
            }
        }
        return getManageableAssociationEnds2r;
    }

    /**
     * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
     * @return  List
     */
    protected abstract List handleGetManageableAssociationEnds();

    private ManageableEntityAttribute __getDisplayAttribute3r;
    private boolean __getDisplayAttribute3rSet = false;

    /**
     * An Entity that is Manageable: will produce CRUD operations in the EntityManager
     * implementation.
     * @return (ManageableEntityAttribute)handleGetDisplayAttribute()
     */
    public final ManageableEntityAttribute getDisplayAttribute()
    {
        ManageableEntityAttribute getDisplayAttribute3r = this.__getDisplayAttribute3r;
        if (!this.__getDisplayAttribute3rSet)
        {
            // manageableEntity has no pre constraints
            Object result = handleGetDisplayAttribute();
            MetafacadeBase shieldedResult = this.shieldedElement(result);
            try
            {
                getDisplayAttribute3r = (ManageableEntityAttribute)shieldedResult;
            }
            catch (ClassCastException ex)
            {
                // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
                ManageableEntityLogic.logger.warn("incorrect metafacade cast for ManageableEntityLogic.getDisplayAttribute ManageableEntityAttribute " + result + ": " + shieldedResult);
            }
            // manageableEntity has no post constraints
            this.__getDisplayAttribute3r = getDisplayAttribute3r;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__getDisplayAttribute3rSet = true;
            }
        }
        return getDisplayAttribute3r;
    }

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

    /**
     * An Entity that is Manageable: will produce CRUD operations in the EntityManager
     * implementation.
     * @return (List<ManageableEntity>)handleGetReferencingManageables()
     */
    public final List<ManageableEntity> getReferencingManageables()
    {
        List<ManageableEntity> getReferencingManageables4r = null;
        // manageableEntity has no pre constraints
        List result = handleGetReferencingManageables();
        List shieldedResult = this.shieldedElements(result);
        try
        {
            getReferencingManageables4r = (List<ManageableEntity>)shieldedResult;
        }
        catch (ClassCastException ex)
        {
            // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
            ManageableEntityLogic.logger.warn("incorrect metafacade cast for ManageableEntityLogic.getReferencingManageables List<ManageableEntity> " + result + ": " + shieldedResult);
        }
        // manageableEntity has no post constraints
        return getReferencingManageables4r;
    }

    /**
     * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
     * @return  List
     */
    protected abstract List handleGetReferencingManageables();

    private List<ManageableEntity> __getAllManageables5r;
    private boolean __getAllManageables5rSet = false;

    /**
     * An Entity that is Manageable: will produce CRUD operations in the EntityManager
     * implementation.
     * @return (List<ManageableEntity>)handleGetAllManageables()
     */
    public final List<ManageableEntity> getAllManageables()
    {
        List<ManageableEntity> getAllManageables5r = this.__getAllManageables5r;
        if (!this.__getAllManageables5rSet)
        {
            // manageableEntity has no pre constraints
            List result = handleGetAllManageables();
            List shieldedResult = this.shieldedElements(result);
            try
            {
                getAllManageables5r = (List<ManageableEntity>)shieldedResult;
            }
            catch (ClassCastException ex)
            {
                // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
                ManageableEntityLogic.logger.warn("incorrect metafacade cast for ManageableEntityLogic.getAllManageables List<ManageableEntity> " + result + ": " + shieldedResult);
            }
            // manageableEntity has no post constraints
            this.__getAllManageables5r = getAllManageables5r;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__getAllManageables5rSet = true;
            }
        }
        return getAllManageables5r;
    }

    /**
     * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
     * @return  List
     */
    protected abstract List handleGetAllManageables();

    private List<ManageableEntityAttribute> __getManageableAttributes6r;
    private boolean __getManageableAttributes6rSet = false;

    /**
     * An Entity that is Manageable: will produce CRUD operations in the EntityManager
     * implementation.
     * @return (List<ManageableEntityAttribute>)handleGetManageableAttributes()
     */
    public final List<ManageableEntityAttribute> getManageableAttributes()
    {
        List<ManageableEntityAttribute> getManageableAttributes6r = this.__getManageableAttributes6r;
        if (!this.__getManageableAttributes6rSet)
        {
            // manageableEntity has no pre constraints
            List result = handleGetManageableAttributes();
            List shieldedResult = this.shieldedElements(result);
            try
            {
                getManageableAttributes6r = (List<ManageableEntityAttribute>)shieldedResult;
            }
            catch (ClassCastException ex)
            {
                // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
                ManageableEntityLogic.logger.warn("incorrect metafacade cast for ManageableEntityLogic.getManageableAttributes List<ManageableEntityAttribute> " + result + ": " + shieldedResult);
            }
            // manageableEntity has no post constraints
            this.__getManageableAttributes6r = getManageableAttributes6r;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__getManageableAttributes6rSet = true;
            }
        }
        return getManageableAttributes6r;
    }

    /**
     * UML Specific type is returned in Collection, transformed by shieldedElements to AndroMDA Metafacade type
     * @return  List
     */
    protected abstract List handleGetManageableAttributes();

    private ManageableEntityAttribute __getManageableIdentifier7r;
    private boolean __getManageableIdentifier7rSet = false;

    /**
     * An Entity that is Manageable: will produce CRUD operations in the EntityManager
     * implementation.
     * @return (ManageableEntityAttribute)handleGetManageableIdentifier()
     */
    public final ManageableEntityAttribute getManageableIdentifier()
    {
        ManageableEntityAttribute getManageableIdentifier7r = this.__getManageableIdentifier7r;
        if (!this.__getManageableIdentifier7rSet)
        {
            // manageableEntity has no pre constraints
            Object result = handleGetManageableIdentifier();
            MetafacadeBase shieldedResult = this.shieldedElement(result);
            try
            {
                getManageableIdentifier7r = (ManageableEntityAttribute)shieldedResult;
            }
            catch (ClassCastException ex)
            {
                // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
                ManageableEntityLogic.logger.warn("incorrect metafacade cast for ManageableEntityLogic.getManageableIdentifier ManageableEntityAttribute " + result + ": " + shieldedResult);
            }
            // manageableEntity has no post constraints
            this.__getManageableIdentifier7r = getManageableIdentifier7r;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__getManageableIdentifier7rSet = true;
            }
        }
        return getManageableIdentifier7r;
    }

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

    /**
     * @param validationMessages Collection<ModelValidationMessage>
     * @see EntityLogicImpl#validateInvariants(Collection validationMessages)
     */
    @Override
    public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
    {
        super.validateInvariants(validationMessages);
    }
}