protected internal override void InternalStateChange_To_AccessControl_ReceiveFSM_Receiving_Ready_NotControlled_AvailableTransition(AccessControl_ReceiveFSMContext context, InternalEvent ie)
                {
                    AccessControl_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : AccessControl_ReceiveFSM_SM.Receiving_Ready_Controlled_Available.InternalStateChange_To_AccessControl_ReceiveFSM_Receiving_Ready_NotControlled_AvailableTransition(, InternalEvent ie)");
                    #endif

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

                    try
                    {
                        ctxt.initAction();
                        ctxt.processNotifications("Receiving_Ready_NotControlled_Available", ie);
                    }
                    finally
                    {
                        context.State = AccessControl_ReceiveFSM_SM.Receiving_Ready_NotControlled_Available;
                        context.State.Entry(context);
                    }

                    return;
                }
                protected internal override void ReceiveTransition(AccessControl_ReceiveFSMContext context, RequestControl msg, Receive.Body.ReceiveRec transportData)
                {
                    AccessControl_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : AccessControl_ReceiveFSM_SM.Receiving_Ready_NotControlled_Available.ReceiveTransition(, RequestControl msg, Receive.Body.ReceiveRec transportData)");
                    #endif

                    if (ctxt.isDefaultAuthorityGreater(msg))
                    {
                        AccessControl_ReceiveFSMState endState = context.State;

                        context.ClearState();

                        try
                        {
                            ctxt.SendAction("ConfirmControl", "INSUFFICIENT_AUTHORITY", transportData);
                        }
                        finally
                        {
                            context.State = endState;
                        }

                    }
                    else if (! ctxt.isDefaultAuthorityGreater(msg))
                    {

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

                        try
                        {
                            ctxt.StoreAddressAction(transportData);
                            ctxt.SetAuthorityAction(msg);
                            ctxt.ResetTimerAction();
                            ctxt.SendAction("ConfirmControl", "CONTROL_ACCEPTED", transportData);
                            ctxt.processNotifications("Receiving_Ready_Controlled_Available", null);
                        }
                        finally
                        {
                            context.State = AccessControl_ReceiveFSM_SM.Receiving_Ready_Controlled_Available;
                            context.State.Entry(context);
                        }

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

                    return;
                }
                protected internal override void ReceiveTransition(AccessControl_ReceiveFSMContext context, RequestControl msg, Receive.Body.ReceiveRec transportData)
                {
                    AccessControl_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : AccessControl_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable.ReceiveTransition(, RequestControl msg, Receive.Body.ReceiveRec transportData)");
                    #endif

                    AccessControl_ReceiveFSMState endState = context.State;

                    context.ClearState();

                    try
                    {
                        ctxt.SendAction("ConfirmControl", "NOT_AVAILABLE", transportData);
                    }
                    finally
                    {
                        context.State = endState;
                    }

                    return;
                }
                protected internal override void ReceiveTransition(AccessControl_ReceiveFSMContext context, QueryAuthority msg, Receive.Body.ReceiveRec transportData)
                {
                    AccessControl_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : AccessControl_ReceiveFSM_SM.Receiving_Ready_NotControlled_Available.ReceiveTransition(, QueryAuthority msg, Receive.Body.ReceiveRec transportData)");
                    #endif

                    AccessControl_ReceiveFSMState endState = context.State;

                    context.ClearState();

                    try
                    {
                        ctxt.SendAction("ReportAuthority", transportData);
                    }
                    finally
                    {
                        context.State = endState;
                    }

                    return;
                }
                protected internal override void TimeoutTransition(AccessControl_ReceiveFSMContext context)
                {
                    AccessControl_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : AccessControl_ReceiveFSM_SM.Receiving_Ready_Controlled_NotAvailable.TimeoutTransition()");
                    #endif

                    AccessControl_ReceiveFSMState endState = context.State;

                    context.ClearState();

                    try
                    {
                        ctxt.resetTimerAction();
                    }
                    finally
                    {
                        context.State = endState;
                    }

                    return;
                }
                protected internal override void ReceiveTransition(AccessControl_ReceiveFSMContext context, SetAuthority msg, Receive.Body.ReceiveRec transportData)
                {
                    AccessControl_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : AccessControl_ReceiveFSM_SM.Receiving_Ready_Controlled_NotAvailable.ReceiveTransition(, SetAuthority msg, Receive.Body.ReceiveRec transportData)");
                    #endif

                    if (ctxt.isAuthorityValid(msg) && ctxt.isControllingClient( transportData ))
                    {
                        AccessControl_ReceiveFSMState endState = context.State;

                        context.ClearState();

                        try
                        {
                            ctxt.SetAuthorityAction(msg);
                        }
                        finally
                        {
                            context.State = endState;
                        }

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

                    return;
                }
                protected internal override void TimeoutTransition(AccessControl_ReceiveFSMContext context)
                {
                    AccessControl_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : AccessControl_ReceiveFSM_SM.Receiving_Ready_Controlled_Available.TimeoutTransition()");
                    #endif

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

                    try
                    {
                        ctxt.SendAction("RejectControl", "CONTROL_RELEASED");
                        ctxt.initAction();
                        ctxt.processNotifications("Receiving_Ready_NotControlled_Available", null);
                    }
                    finally
                    {
                        context.State = AccessControl_ReceiveFSM_SM.Receiving_Ready_NotControlled_Available;
                        context.State.Entry(context);
                    }

                    return;
                }
                protected internal override void ReceiveTransition(AccessControl_ReceiveFSMContext context, ReleaseControl msg, Receive.Body.ReceiveRec transportData)
                {
                    AccessControl_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : AccessControl_ReceiveFSM_SM.Receiving_Ready_Controlled_Available.ReceiveTransition(, ReleaseControl msg, Receive.Body.ReceiveRec transportData)");
                    #endif

                    if (ctxt.isControllingClient( transportData ))
                    {

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

                        try
                        {
                            ctxt.SendAction("RejectControl", "CONTROL_RELEASED", transportData);
                            ctxt.initAction();
                            ctxt.processNotifications("Receiving_Ready_NotControlled_Available", null);
                        }
                        finally
                        {
                            context.State = AccessControl_ReceiveFSM_SM.Receiving_Ready_NotControlled_Available;
                            context.State.Entry(context);
                        }

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

                    return;
                }