// 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.common.Introspector;
import org.andromda.core.metafacade.MetafacadeBase;
import org.andromda.core.metafacade.ModelValidationMessage;
import org.andromda.metafacades.uml.ActionStateFacade;
import org.andromda.metafacades.uml.ActivityGraphFacade;
import org.andromda.metafacades.uml.ActorFacade;
import org.andromda.metafacades.uml.ClassifierFacade;
import org.andromda.metafacades.uml.FinalStateFacade;
import org.andromda.metafacades.uml.ModelFacade;
import org.andromda.metafacades.uml.ObjectFlowStateFacade;
import org.andromda.metafacades.uml.PackageFacade;
import org.andromda.metafacades.uml.TransitionFacade;
import org.andromda.metafacades.uml.UseCaseFacade;
import org.apache.log4j.Logger;
import org.omg.uml.UmlPackage;

/**
 * Captures a view of a physical system. It is an abstraction of the physical system, with a certain
 * purpose. This purpose determines what is to be included in the model and what is irrelevant. Thus
 * the model completely describes those aspects of the physical system that are relevant to the
 * purpose of the model, at the appropriate level of detail. May be a UML2 model or package.
 * MetafacadeLogic for ModelFacade
 *
 * @see ModelFacade
 */
public abstract class ModelFacadeLogic
    extends MetafacadeBase
    implements ModelFacade
{
    /**
     * The underlying UML object
     * @see UmlPackage
     */
    protected UmlPackage metaObject;

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

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

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

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

    /**
     * Method to be implemented in descendants
     * Return the UseCase belonging to this model with the tagged value or hyperlink.
     * @param tag
     * @param value
     * @return UseCaseFacade
     */
    protected abstract UseCaseFacade handleFindUseCaseWithTaggedValueOrHyperlink(String tag, String value);

    /**
     * Return the UseCase belonging to this model with the tagged value or hyperlink.
     * @param tag String
     * TODO: Model Documentation for
     * ModelFacade.findUseCaseWithTaggedValueOrHyperlink(tag)
     * @param value String
     * TODO: Model Documentation for
     * ModelFacade.findUseCaseWithTaggedValueOrHyperlink(value)
     * @return handleFindUseCaseWithTaggedValueOrHyperlink(tag, value)
     */
    public UseCaseFacade findUseCaseWithTaggedValueOrHyperlink(String tag, String value)
    {
        // findUseCaseWithTaggedValueOrHyperlink has no pre constraints
        UseCaseFacade returnValue = handleFindUseCaseWithTaggedValueOrHyperlink(tag, value);
        // findUseCaseWithTaggedValueOrHyperlink has no post constraints
        return returnValue;
    }

    /**
     * Method to be implemented in descendants
     * Return the Class belonging to this model with the tagged value or hyperlink.
     * @param tag
     * @param value
     * @return ClassifierFacade
     */
    protected abstract ClassifierFacade handleFindClassWithTaggedValueOrHyperlink(String tag, String value);

    /**
     * Return the Class belonging to this model with the tagged value or hyperlink.
     * @param tag String
     * TODO: Model Documentation for
     * ModelFacade.findClassWithTaggedValueOrHyperlink(tag)
     * @param value String
     * TODO: Model Documentation for
     * ModelFacade.findClassWithTaggedValueOrHyperlink(value)
     * @return handleFindClassWithTaggedValueOrHyperlink(tag, value)
     */
    public ClassifierFacade findClassWithTaggedValueOrHyperlink(String tag, String value)
    {
        // findClassWithTaggedValueOrHyperlink has no pre constraints
        ClassifierFacade returnValue = handleFindClassWithTaggedValueOrHyperlink(tag, value);
        // findClassWithTaggedValueOrHyperlink has no post constraints
        return returnValue;
    }

    /**
     * Method to be implemented in descendants
     * Finds the ActivityGraph with the Name.
     * @param name
     * @return ActivityGraphFacade
     */
    protected abstract ActivityGraphFacade handleFindActivityGraphByName(String name);

    /**
     * Finds the ActivityGraph with the Name.
     * @param name String
     * TODO: Model Documentation for
     * ModelFacade.findActivityGraphByName(name)
     * @return handleFindActivityGraphByName(name)
     */
    public ActivityGraphFacade findActivityGraphByName(String name)
    {
        // findActivityGraphByName has no pre constraints
        ActivityGraphFacade returnValue = handleFindActivityGraphByName(name);
        // findActivityGraphByName has no post constraints
        return returnValue;
    }

    /**
     * Method to be implemented in descendants
     * Finds the ActivityGraph with the Name and Stereotype.
     * @param name
     * @param stereotypeName
     * @return ActivityGraphFacade
     */
    protected abstract ActivityGraphFacade handleFindActivityGraphByNameAndStereotype(String name, String stereotypeName);

    /**
     * Finds the ActivityGraph with the Name and Stereotype.
     * @param name String
     * TODO: Model Documentation for
     * ModelFacade.findActivityGraphByNameAndStereotype(name)
     * @param stereotypeName String
     * TODO: Model Documentation for
     * ModelFacade.findActivityGraphByNameAndStereotype(stereotypeName)
     * @return handleFindActivityGraphByNameAndStereotype(name, stereotypeName)
     */
    public ActivityGraphFacade findActivityGraphByNameAndStereotype(String name, String stereotypeName)
    {
        // findActivityGraphByNameAndStereotype has no pre constraints
        ActivityGraphFacade returnValue = handleFindActivityGraphByNameAndStereotype(name, stereotypeName);
        // findActivityGraphByNameAndStereotype has no post constraints
        return returnValue;
    }

    /**
     * Method to be implemented in descendants
     * Finds the UseCase with the Name.
     * @param name
     * @return UseCaseFacade
     */
    protected abstract UseCaseFacade handleFindUseCaseByName(String name);

    /**
     * Finds the UseCase with the Name.
     * @param name String
     * TODO: Model Documentation for
     * ModelFacade.findUseCaseByName(name)
     * @return handleFindUseCaseByName(name)
     */
    public UseCaseFacade findUseCaseByName(String name)
    {
        // findUseCaseByName has no pre constraints
        UseCaseFacade returnValue = handleFindUseCaseByName(name);
        // findUseCaseByName has no post constraints
        return returnValue;
    }

    /**
     * Method to be implemented in descendants
     * Finds the UseGraph with the Name and Stereotype.
     * @param name
     * @param stereotypeName
     * @return UseCaseFacade
     */
    protected abstract UseCaseFacade handleFindUseCaseWithNameAndStereotype(String name, String stereotypeName);

    /**
     * Finds the UseGraph with the Name and Stereotype.
     * @param name String
     * TODO: Model Documentation for
     * ModelFacade.findUseCaseWithNameAndStereotype(name)
     * @param stereotypeName String
     * TODO: Model Documentation for
     * ModelFacade.findUseCaseWithNameAndStereotype(stereotypeName)
     * @return handleFindUseCaseWithNameAndStereotype(name, stereotypeName)
     */
    public UseCaseFacade findUseCaseWithNameAndStereotype(String name, String stereotypeName)
    {
        // findUseCaseWithNameAndStereotype has no pre constraints
        UseCaseFacade returnValue = handleFindUseCaseWithNameAndStereotype(name, stereotypeName);
        // findUseCaseWithNameAndStereotype has no post constraints
        return returnValue;
    }

    /**
     * Method to be implemented in descendants
     * Finds the FinalState with the Name or Hyperlink.
     * @param useCase
     * @return Collection<FinalStateFacade>
     */
    protected abstract Collection<FinalStateFacade> handleFindFinalStatesWithNameOrHyperlink(UseCaseFacade useCase);

    /**
     * Finds the FinalState with the Name or Hyperlink.
     * @param useCase UseCaseFacade
     * TODO: Model Documentation for
     * ModelFacade.findFinalStatesWithNameOrHyperlink(useCase)
     * @return handleFindFinalStatesWithNameOrHyperlink(useCase)
     */
    public Collection<FinalStateFacade> findFinalStatesWithNameOrHyperlink(UseCaseFacade useCase)
    {
        // findFinalStatesWithNameOrHyperlink has no pre constraints
        Collection<FinalStateFacade> returnValue = handleFindFinalStatesWithNameOrHyperlink(useCase);
        // findFinalStatesWithNameOrHyperlink has no post constraints
        return returnValue;
    }

    /**
     * Method to be implemented in descendants
     * Finds all ActionStates with the Stereotype.
     * @param activityGraph
     * @param stereotypeName
     * @return Collection<ActionStateFacade>
     */
    protected abstract Collection<ActionStateFacade> handleGetAllActionStatesWithStereotype(ActivityGraphFacade activityGraph, String stereotypeName);

    /**
     * Finds all ActionStates with the Stereotype.
     * @param activityGraph ActivityGraphFacade
     * TODO: Model Documentation for
     * ModelFacade.getAllActionStatesWithStereotype(activityGraph)
     * @param stereotypeName String
     * TODO: Model Documentation for
     * ModelFacade.getAllActionStatesWithStereotype(stereotypeName)
     * @return handleGetAllActionStatesWithStereotype(activityGraph, stereotypeName)
     */
    public Collection<ActionStateFacade> getAllActionStatesWithStereotype(ActivityGraphFacade activityGraph, String stereotypeName)
    {
        // getAllActionStatesWithStereotype has no pre constraints
        Collection<ActionStateFacade> returnValue = handleGetAllActionStatesWithStereotype(activityGraph, stereotypeName);
        // getAllActionStatesWithStereotype has no post constraints
        return returnValue;
    }

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

    private Collection<ClassifierFacade> __getAllClasses1r;
    private boolean __getAllClasses1rSet = false;

    /**
     * Captures a view of a physical system. It is an abstraction of the physical system, with a
     * certain
     * purpose. This purpose determines what is to be included in the model and what is irrelevant.
     * Thus
     * the model completely describes those aspects of the physical system that are relevant to the
     * purpose
     * of the model, at the appropriate level of detail. May be a UML2 model or package.
     * @return (Collection<ClassifierFacade>)handleGetAllClasses()
     */
    public final Collection<ClassifierFacade> getAllClasses()
    {
        Collection<ClassifierFacade> getAllClasses1r = this.__getAllClasses1r;
        if (!this.__getAllClasses1rSet)
        {
            // modelFacade has no pre constraints
            Collection result = handleGetAllClasses();
            List shieldedResult = this.shieldedElements(result);
            try
            {
                getAllClasses1r = (Collection<ClassifierFacade>)shieldedResult;
            }
            catch (ClassCastException ex)
            {
                // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
                ModelFacadeLogic.logger.warn("incorrect metafacade cast for ModelFacadeLogic.getAllClasses Collection<ClassifierFacade> " + result + ": " + shieldedResult);
            }
            // modelFacade has no post constraints
            this.__getAllClasses1r = getAllClasses1r;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__getAllClasses1rSet = true;
            }
        }
        return getAllClasses1r;
    }

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

    /**
     * Captures a view of a physical system. It is an abstraction of the physical system, with a
     * certain
     * purpose. This purpose determines what is to be included in the model and what is irrelevant.
     * Thus
     * the model completely describes those aspects of the physical system that are relevant to the
     * purpose
     * of the model, at the appropriate level of detail. May be a UML2 model or package.
     * @return (PackageFacade)handleGetRootPackage()
     */
    public final PackageFacade getRootPackage()
    {
        PackageFacade getRootPackage2r = null;
        // modelFacade has no pre constraints
        Object result = handleGetRootPackage();
        MetafacadeBase shieldedResult = this.shieldedElement(result);
        try
        {
            getRootPackage2r = (PackageFacade)shieldedResult;
        }
        catch (ClassCastException ex)
        {
            // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
            ModelFacadeLogic.logger.warn("incorrect metafacade cast for ModelFacadeLogic.getRootPackage PackageFacade " + result + ": " + shieldedResult);
        }
        // modelFacade has no post constraints
        return getRootPackage2r;
    }

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

    private Collection<TransitionFacade> __getAllTransitions3r;
    private boolean __getAllTransitions3rSet = false;

    /**
     * Captures a view of a physical system. It is an abstraction of the physical system, with a
     * certain
     * purpose. This purpose determines what is to be included in the model and what is irrelevant.
     * Thus
     * the model completely describes those aspects of the physical system that are relevant to the
     * purpose
     * of the model, at the appropriate level of detail. May be a UML2 model or package.
     * @return (Collection<TransitionFacade>)handleGetAllTransitions()
     */
    public final Collection<TransitionFacade> getAllTransitions()
    {
        Collection<TransitionFacade> getAllTransitions3r = this.__getAllTransitions3r;
        if (!this.__getAllTransitions3rSet)
        {
            // modelFacade has no pre constraints
            Collection result = handleGetAllTransitions();
            List shieldedResult = this.shieldedElements(result);
            try
            {
                getAllTransitions3r = (Collection<TransitionFacade>)shieldedResult;
            }
            catch (ClassCastException ex)
            {
                // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
                ModelFacadeLogic.logger.warn("incorrect metafacade cast for ModelFacadeLogic.getAllTransitions Collection<TransitionFacade> " + result + ": " + shieldedResult);
            }
            // modelFacade has no post constraints
            this.__getAllTransitions3r = getAllTransitions3r;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__getAllTransitions3rSet = true;
            }
        }
        return getAllTransitions3r;
    }

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

    /**
     * Captures a view of a physical system. It is an abstraction of the physical system, with a
     * certain
     * purpose. This purpose determines what is to be included in the model and what is irrelevant.
     * Thus
     * the model completely describes those aspects of the physical system that are relevant to the
     * purpose
     * of the model, at the appropriate level of detail. May be a UML2 model or package.
     * @return (Collection<ActorFacade>)handleGetAllActors()
     */
    public final Collection<ActorFacade> getAllActors()
    {
        Collection<ActorFacade> getAllActors4r = null;
        // modelFacade has no pre constraints
        Collection result = handleGetAllActors();
        List shieldedResult = this.shieldedElements(result);
        try
        {
            getAllActors4r = (Collection<ActorFacade>)shieldedResult;
        }
        catch (ClassCastException ex)
        {
            // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
            ModelFacadeLogic.logger.warn("incorrect metafacade cast for ModelFacadeLogic.getAllActors Collection<ActorFacade> " + result + ": " + shieldedResult);
        }
        // modelFacade has no post constraints
        return getAllActors4r;
    }

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

    /**
     * Captures a view of a physical system. It is an abstraction of the physical system, with a
     * certain
     * purpose. This purpose determines what is to be included in the model and what is irrelevant.
     * Thus
     * the model completely describes those aspects of the physical system that are relevant to the
     * purpose
     * of the model, at the appropriate level of detail. May be a UML2 model or package.
     * @return (Collection<UseCaseFacade>)handleGetAllUseCases()
     */
    public final Collection<UseCaseFacade> getAllUseCases()
    {
        Collection<UseCaseFacade> getAllUseCases5r = null;
        // modelFacade has no pre constraints
        Collection result = handleGetAllUseCases();
        List shieldedResult = this.shieldedElements(result);
        try
        {
            getAllUseCases5r = (Collection<UseCaseFacade>)shieldedResult;
        }
        catch (ClassCastException ex)
        {
            // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
            ModelFacadeLogic.logger.warn("incorrect metafacade cast for ModelFacadeLogic.getAllUseCases Collection<UseCaseFacade> " + result + ": " + shieldedResult);
        }
        // modelFacade has no post constraints
        return getAllUseCases5r;
    }

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

    /**
     * Captures a view of a physical system. It is an abstraction of the physical system, with a
     * certain
     * purpose. This purpose determines what is to be included in the model and what is irrelevant.
     * Thus
     * the model completely describes those aspects of the physical system that are relevant to the
     * purpose
     * of the model, at the appropriate level of detail. May be a UML2 model or package.
     * @return (Collection<ActionStateFacade>)handleGetAllActionStates()
     */
    public final Collection<ActionStateFacade> getAllActionStates()
    {
        Collection<ActionStateFacade> getAllActionStates6r = null;
        // modelFacade has no pre constraints
        Collection result = handleGetAllActionStates();
        List shieldedResult = this.shieldedElements(result);
        try
        {
            getAllActionStates6r = (Collection<ActionStateFacade>)shieldedResult;
        }
        catch (ClassCastException ex)
        {
            // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
            ModelFacadeLogic.logger.warn("incorrect metafacade cast for ModelFacadeLogic.getAllActionStates Collection<ActionStateFacade> " + result + ": " + shieldedResult);
        }
        // modelFacade has no post constraints
        return getAllActionStates6r;
    }

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

    private Collection<ObjectFlowStateFacade> __getAllObjectFlowStates7r;
    private boolean __getAllObjectFlowStates7rSet = false;

    /**
     * Captures a view of a physical system. It is an abstraction of the physical system, with a
     * certain
     * purpose. This purpose determines what is to be included in the model and what is irrelevant.
     * Thus
     * the model completely describes those aspects of the physical system that are relevant to the
     * purpose
     * of the model, at the appropriate level of detail. May be a UML2 model or package.
     * @return (Collection<ObjectFlowStateFacade>)handleGetAllObjectFlowStates()
     */
    public final Collection<ObjectFlowStateFacade> getAllObjectFlowStates()
    {
        Collection<ObjectFlowStateFacade> getAllObjectFlowStates7r = this.__getAllObjectFlowStates7r;
        if (!this.__getAllObjectFlowStates7rSet)
        {
            // modelFacade has no pre constraints
            Collection result = handleGetAllObjectFlowStates();
            List shieldedResult = this.shieldedElements(result);
            try
            {
                getAllObjectFlowStates7r = (Collection<ObjectFlowStateFacade>)shieldedResult;
            }
            catch (ClassCastException ex)
            {
                // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
                ModelFacadeLogic.logger.warn("incorrect metafacade cast for ModelFacadeLogic.getAllObjectFlowStates Collection<ObjectFlowStateFacade> " + result + ": " + shieldedResult);
            }
            // modelFacade has no post constraints
            this.__getAllObjectFlowStates7r = getAllObjectFlowStates7r;
            if (isMetafacadePropertyCachingEnabled())
            {
                this.__getAllObjectFlowStates7rSet = true;
            }
        }
        return getAllObjectFlowStates7r;
    }

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

    /**
     * @param validationMessages Collection<ModelValidationMessage>
     * @see MetafacadeBase#validateInvariants(Collection validationMessages)
     */
    @Override
    public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
    {
    }

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