public Management_ReceiveFSM(urn_jaus_jss_core_Transport_1_1.Transport_ReceiveFSM pTransport_ReceiveFSM, urn_jaus_jss_core_Events_1_1.Events_ReceiveFSM pEvents_ReceiveFSM, urn_jaus_jss_core_AccessControl_1_1.AccessControl_ReceiveFSM pAccessControl_ReceiveFSM)
        {
            /*
             * If there are other variables, context must be constructed last so that all
             * class variables are available if an EntryAction of the InitialState of the
             * statemachine needs them.
             */
            context = new Management_ReceiveFSMContext(this);

            this.pTransport_ReceiveFSM = pTransport_ReceiveFSM;
            this.pEvents_ReceiveFSM = pEvents_ReceiveFSM;
            this.pAccessControl_ReceiveFSM = pAccessControl_ReceiveFSM;
        }

                protected internal override void ReceiveTransition(Management_ReceiveFSMContext context, Resume msg, Receive.Body.ReceiveRec transportData)
                {
                    Management_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : Management_ReceiveFSM_SM.Receiving_Ready_Controlled_Available_Standby.ReceiveTransition(, Resume msg, Receive.Body.ReceiveRec transportData)");
                    #endif

                    if (ctxt.isControllingClient( transportData ))
                    {

                        context.State.Exit(context);
                        context.ClearState();

                        try
                        {
                            ctxt.processNotifications("Receiving_Ready_Controlled_Available_Ready", null);
                        }
                        finally
                        {
                            context.State = Management_ReceiveFSM_SM.Receiving_Ready_Controlled_Available_Ready;
                            context.State.Entry(context);
                        }

                    }
                    else                    {
                        base.ReceiveTransition(context, msg, transportData);
                    }

                    return;
                }

 protected internal virtual void UpdateEventTransition(Management_ReceiveFSMContext context)
 {
     Default(context);
 }

 protected internal virtual void RequestControlTransition(Management_ReceiveFSMContext context)
 {
     Default(context);
 }

 protected internal virtual void QueryTimeoutTransition(Management_ReceiveFSMContext context)
 {
     Default(context);
 }

 protected internal virtual void InternalStateChange_To_Management_ReceiveFSM_Receiving_ReadyTransition(Management_ReceiveFSMContext context, InternalEvent ie)
 {
     Default(context);
 }

 protected internal virtual void Exit(Management_ReceiveFSMContext context)
 {
 }

                protected internal override void FailureTransition(Management_ReceiveFSMContext context)
                {
                    Management_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : Management_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable_Shutdown.FailureTransition()");
                    #endif

                    context.State.Exit(context);
                        context.ClearState();

                        try
                        {
                        ctxt.processNotifications("Receiving_Ready_NotControlled_NotAvailable_Failure", null);
                        }
                        finally
                        {
                        context.State = Management_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable_Failure;
                        context.State.Entry(context);
                        }

                    return;
                }

                protected internal override void TimeoutTransition(Management_ReceiveFSMContext context)
                {
                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : Management_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable_Emergency.TimeoutTransition()");
                    #endif

                    return;
                }

 protected internal virtual void Default(Management_ReceiveFSMContext context)
 {
     #if TRACE
     Trace.WriteLine(
         "TRANSITION : Default");
     #endif
     throw (
         new statemap.TransitionUndefinedException(
             "State: " +
             context.State.Name +
             ", Transition: " +
             context.GetTransition()));
 }

 protected internal virtual void EventOccurredTransition(Management_ReceiveFSMContext context)
 {
     Default(context);
 }

                protected internal override void InternalStateChange_To_Management_ReceiveFSM_Receiving_Ready_NotControlled_NotAvailable_InitTransition(Management_ReceiveFSMContext context, InternalEvent ie)
                {
                    Management_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : Management_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable_Shutdown.InternalStateChange_To_Management_ReceiveFSM_Receiving_Ready_NotControlled_NotAvailable_InitTransition(, InternalEvent ie)");
                    #endif

                    context.State.Exit(context);
                    context.ClearState();

                    try
                    {
                        ctxt.initializeAction();
                        ctxt.processNotifications("Receiving_Ready_NotControlled_NotAvailable_Init", ie);
                    }
                    finally
                    {
                        context.State = Management_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable_Init;
                        context.State.Entry(context);
                    }

                    return;
                }

 protected internal virtual void InitializedTransition(Management_ReceiveFSMContext context)
 {
     Default(context);
 }

 protected internal virtual void BroadcastLocalTransition(Management_ReceiveFSMContext context)
 {
     Default(context);
 }

 protected internal virtual void ClearEmergencyTransition(Management_ReceiveFSMContext context)
 {
     Default(context);
 }

 protected internal virtual void StandbyTransition(Management_ReceiveFSMContext context)
 {
     Default(context);
 }

 protected internal virtual void CommandCompletedTransition(Management_ReceiveFSMContext context)
 {
     Default(context);
 }

 protected internal virtual void CreateCommandEventTransition(Management_ReceiveFSMContext context)
 {
     Default(context);
 }