// 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.ActionFacade;
  import org.andromda.metafacades.uml.EventFacade;
  import org.andromda.metafacades.uml.GuardFacade;
  import org.andromda.metafacades.uml.StateVertexFacade;
  import org.andromda.metafacades.uml.TransitionFacade;
  import org.apache.log4j.Logger;
  import org.omg.uml.behavioralelements.statemachines.Transition;
  
  /**
   * A directed relationship between a source vertex and a target vertex. It may be part of a compound
   * transition, which takes the state machine from one state configuration to another, representing
   * the complete response of the state machine to an occurrence of an event of a particular type.
   * MetafacadeLogic for TransitionFacade
   *
   * @see TransitionFacade
   */
  public abstract class TransitionFacadeLogic
      extends ModelElementFacadeLogicImpl
      implements TransitionFacade
  {
      /**
       * The underlying UML object
       * @see Transition
       */
      protected Transition metaObject;
  
      /** Create Metafacade implementation instance using the MetafacadeFactory from the context
       * @param metaObjectIn
       * @param context
       */
      protected TransitionFacadeLogic(Transition metaObjectIn, String context)
      {
          super(metaObjectIn, getContext(context));
          this.metaObject = metaObjectIn;
      }
  
      /**
       * The logger instance.
       */
      private static final Logger logger = Logger.getLogger(TransitionFacadeLogic.class);
  
      /**
       * Gets the context for this metafacade logic instance.
       * @param context String. Set to TransitionFacade if null
       * @return context String
       */
      private static String getContext(String context)
      {
          if (context == null)
          {
              context = "org.andromda.metafacades.uml.TransitionFacade";
          }
          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 TransitionFacade
       */
      public boolean isTransitionFacadeMetaType()
      {
          return true;
      }
  
      // --------------- attributes ---------------------
  
     /**
      * @see TransitionFacade#isTriggerPresent()
      * @return boolean
      */
      protected abstract boolean handleIsTriggerPresent();
  
      private boolean __triggerPresent1a;
      private boolean __triggerPresent1aSet = false;
  
      /**
       * TODO: Model Documentation for TransitionFacade.triggerPresent
      * @return (boolean)handleIsTriggerPresent()
      */
     public final boolean isTriggerPresent()
     {
         boolean triggerPresent1a = this.__triggerPresent1a;
         if (!this.__triggerPresent1aSet)
         {
             // triggerPresent has no pre constraints
             triggerPresent1a = handleIsTriggerPresent();
             // triggerPresent has no post constraints
             this.__triggerPresent1a = triggerPresent1a;
             if (isMetafacadePropertyCachingEnabled())
             {
                 this.__triggerPresent1aSet = true;
             }
         }
         return triggerPresent1a;
     }
 
    /**
     * @see TransitionFacade#isExitingDecisionPoint()
     * @return boolean
     */
     protected abstract boolean handleIsExitingDecisionPoint();
 
     private boolean __exitingDecisionPoint2a;
     private boolean __exitingDecisionPoint2aSet = false;
 
     /**
      * TODO: Model Documentation for
      * TransitionFacade.exitingDecisionPoint
      * @return (boolean)handleIsExitingDecisionPoint()
      */
     public final boolean isExitingDecisionPoint()
     {
         boolean exitingDecisionPoint2a = this.__exitingDecisionPoint2a;
         if (!this.__exitingDecisionPoint2aSet)
         {
             // exitingDecisionPoint has no pre constraints
             exitingDecisionPoint2a = handleIsExitingDecisionPoint();
             // exitingDecisionPoint has no post constraints
             this.__exitingDecisionPoint2a = exitingDecisionPoint2a;
             if (isMetafacadePropertyCachingEnabled())
             {
                 this.__exitingDecisionPoint2aSet = true;
             }
         }
         return exitingDecisionPoint2a;
     }
 
    /**
     * @see TransitionFacade#isEnteringDecisionPoint()
     * @return boolean
     */
     protected abstract boolean handleIsEnteringDecisionPoint();
 
     private boolean __enteringDecisionPoint3a;
     private boolean __enteringDecisionPoint3aSet = false;
 
     /**
      * TODO: Model Documentation for
      * TransitionFacade.enteringDecisionPoint
      * @return (boolean)handleIsEnteringDecisionPoint()
      */
     public final boolean isEnteringDecisionPoint()
     {
         boolean enteringDecisionPoint3a = this.__enteringDecisionPoint3a;
         if (!this.__enteringDecisionPoint3aSet)
         {
             // enteringDecisionPoint has no pre constraints
             enteringDecisionPoint3a = handleIsEnteringDecisionPoint();
             // enteringDecisionPoint has no post constraints
             this.__enteringDecisionPoint3a = enteringDecisionPoint3a;
             if (isMetafacadePropertyCachingEnabled())
             {
                 this.__enteringDecisionPoint3aSet = true;
             }
         }
         return enteringDecisionPoint3a;
     }
 
    /**
     * @see TransitionFacade#isExitingActionState()
     * @return boolean
     */
     protected abstract boolean handleIsExitingActionState();
 
     private boolean __exitingActionState4a;
     private boolean __exitingActionState4aSet = false;
 
     /**
      * TODO: Model Documentation for
      * TransitionFacade.exitingActionState
      * @return (boolean)handleIsExitingActionState()
      */
     public final boolean isExitingActionState()
     {
         boolean exitingActionState4a = this.__exitingActionState4a;
         if (!this.__exitingActionState4aSet)
         {
             // exitingActionState has no pre constraints
             exitingActionState4a = handleIsExitingActionState();
             // exitingActionState has no post constraints
             this.__exitingActionState4a = exitingActionState4a;
             if (isMetafacadePropertyCachingEnabled())
             {
                 this.__exitingActionState4aSet = true;
             }
         }
         return exitingActionState4a;
     }
 
    /**
     * @see TransitionFacade#isEnteringActionState()
     * @return boolean
     */
     protected abstract boolean handleIsEnteringActionState();
 
     private boolean __enteringActionState5a;
     private boolean __enteringActionState5aSet = false;
 
     /**
      * TODO: Model Documentation for
      * TransitionFacade.enteringActionState
      * @return (boolean)handleIsEnteringActionState()
      */
     public final boolean isEnteringActionState()
     {
         boolean enteringActionState5a = this.__enteringActionState5a;
         if (!this.__enteringActionState5aSet)
         {
             // enteringActionState has no pre constraints
             enteringActionState5a = handleIsEnteringActionState();
             // enteringActionState has no post constraints
             this.__enteringActionState5a = enteringActionState5a;
             if (isMetafacadePropertyCachingEnabled())
             {
                 this.__enteringActionState5aSet = true;
             }
         }
         return enteringActionState5a;
     }
 
    /**
     * @see TransitionFacade#isExitingInitialState()
     * @return boolean
     */
     protected abstract boolean handleIsExitingInitialState();
 
     private boolean __exitingInitialState6a;
     private boolean __exitingInitialState6aSet = false;
 
     /**
      * TODO: Model Documentation for
      * TransitionFacade.exitingInitialState
      * @return (boolean)handleIsExitingInitialState()
      */
     public final boolean isExitingInitialState()
     {
         boolean exitingInitialState6a = this.__exitingInitialState6a;
         if (!this.__exitingInitialState6aSet)
         {
             // exitingInitialState has no pre constraints
             exitingInitialState6a = handleIsExitingInitialState();
             // exitingInitialState has no post constraints
             this.__exitingInitialState6a = exitingInitialState6a;
             if (isMetafacadePropertyCachingEnabled())
             {
                 this.__exitingInitialState6aSet = true;
             }
         }
         return exitingInitialState6a;
     }
 
    /**
     * @see TransitionFacade#isEnteringFinalState()
     * @return boolean
     */
     protected abstract boolean handleIsEnteringFinalState();
 
     private boolean __enteringFinalState7a;
     private boolean __enteringFinalState7aSet = false;
 
     /**
      * TODO: Model Documentation for
      * TransitionFacade.enteringFinalState
      * @return (boolean)handleIsEnteringFinalState()
      */
     public final boolean isEnteringFinalState()
     {
         boolean enteringFinalState7a = this.__enteringFinalState7a;
         if (!this.__enteringFinalState7aSet)
         {
             // enteringFinalState has no pre constraints
             enteringFinalState7a = handleIsEnteringFinalState();
             // enteringFinalState has no post constraints
             this.__enteringFinalState7a = enteringFinalState7a;
             if (isMetafacadePropertyCachingEnabled())
             {
                 this.__enteringFinalState7aSet = true;
             }
         }
         return enteringFinalState7a;
     }
 
     // ------------- associations ------------------
 
     /**
      * A directed relationship between a source vertex and a target vertex. It may be part of a
      * compound
      * transition, which takes the state machine from one state configuration to another,
      * representing the
      * complete response of the state machine to an occurrence of an event of a particular type.
      * @return (GuardFacade)handleGetGuard()
      */
     public final GuardFacade getGuard()
     {
         GuardFacade getGuard1r = null;
         // transition has no pre constraints
         Object result = handleGetGuard();
         MetafacadeBase shieldedResult = this.shieldedElement(result);
         try
         {
             getGuard1r = (GuardFacade)shieldedResult;
         }
         catch (ClassCastException ex)
         {
             // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
             TransitionFacadeLogic.logger.warn("incorrect metafacade cast for TransitionFacadeLogic.getGuard GuardFacade " + result + ": " + shieldedResult);
         }
         // transition has no post constraints
         return getGuard1r;
     }
 
     /**
      * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
      * @return Object
      */
     protected abstract Object handleGetGuard();
 
     /**
      * If this event is located on a transition, this represents that transition.
      * @return (EventFacade)handleGetTrigger()
      */
     public final EventFacade getTrigger()
     {
         EventFacade getTrigger2r = null;
         // transition has no pre constraints
         Object result = handleGetTrigger();
         MetafacadeBase shieldedResult = this.shieldedElement(result);
         try
         {
             getTrigger2r = (EventFacade)shieldedResult;
         }
         catch (ClassCastException ex)
         {
             // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
             TransitionFacadeLogic.logger.warn("incorrect metafacade cast for TransitionFacadeLogic.getTrigger EventFacade " + result + ": " + shieldedResult);
         }
         // transition has no post constraints
         return getTrigger2r;
     }
 
     /**
      * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
      * @return Object
      */
     protected abstract Object handleGetTrigger();
 
     /**
      * A directed relationship between a source vertex and a target vertex. It may be part of a
      * compound
      * transition, which takes the state machine from one state configuration to another,
      * representing the
      * complete response of the state machine to an occurrence of an event of a particular type.
      * @return (StateVertexFacade)handleGetSource()
      */
     public final StateVertexFacade getSource()
     {
         StateVertexFacade getSource3r = null;
         // incomings has no pre constraints
         Object result = handleGetSource();
         MetafacadeBase shieldedResult = this.shieldedElement(result);
         try
         {
             getSource3r = (StateVertexFacade)shieldedResult;
         }
         catch (ClassCastException ex)
         {
             // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
             TransitionFacadeLogic.logger.warn("incorrect metafacade cast for TransitionFacadeLogic.getSource StateVertexFacade " + result + ": " + shieldedResult);
         }
         // incomings has no post constraints
         return getSource3r;
     }
 
     /**
      * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
      * @return Object
      */
     protected abstract Object handleGetSource();
 
     /**
      * A directed relationship between a source vertex and a target vertex. It may be part of a
      * compound
      * transition, which takes the state machine from one state configuration to another,
      * representing the
      * complete response of the state machine to an occurrence of an event of a particular type.
      * @return (StateVertexFacade)handleGetTarget()
      */
     public final StateVertexFacade getTarget()
     {
         StateVertexFacade getTarget4r = null;
         // outgoings has no pre constraints
         Object result = handleGetTarget();
         MetafacadeBase shieldedResult = this.shieldedElement(result);
         try
         {
             getTarget4r = (StateVertexFacade)shieldedResult;
         }
         catch (ClassCastException ex)
         {
             // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
             TransitionFacadeLogic.logger.warn("incorrect metafacade cast for TransitionFacadeLogic.getTarget StateVertexFacade " + result + ": " + shieldedResult);
         }
         // outgoings has no post constraints
         return getTarget4r;
     }
 
     /**
      * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
      * @return Object
      */
     protected abstract Object handleGetTarget();
 
     /**
      * If this action is located on a transition, this represents that transition.
      * @return (ActionFacade)handleGetEffect()
      */
     public final ActionFacade getEffect()
     {
         ActionFacade getEffect5r = null;
         // transition has no pre constraints
         Object result = handleGetEffect();
         MetafacadeBase shieldedResult = this.shieldedElement(result);
         try
         {
             getEffect5r = (ActionFacade)shieldedResult;
         }
         catch (ClassCastException ex)
         {
             // Bad things happen if the metafacade type mapping in metafacades.xml is wrong - Warn
             TransitionFacadeLogic.logger.warn("incorrect metafacade cast for TransitionFacadeLogic.getEffect ActionFacade " + result + ": " + shieldedResult);
         }
         // transition has no post constraints
         return getEffect5r;
     }
 
     /**
      * UML Specific type is transformed by shieldedElements to AndroMDA Metafacade type
      * @return Object
      */
     protected abstract Object handleGetEffect();
 
     /**
      * @param validationMessages Collection<ModelValidationMessage>
      * @see ModelElementFacadeLogicImpl#validateInvariants(Collection validationMessages)
      */
     @Override
     public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
     {
         super.validateInvariants(validationMessages);
     }
 }