//Editor-Info: -*- C++ -*-
//
//Subject: TOVE project
//
//File: unicoordstate.cpp
//
//Version: $Revision: 1.9 $
//
//State: $State: Exp $
//
//Date: $Date: 1999/01/20 08:53:19 $
//
//Organisation:
//      Helsinki University of Technology
//      Laboratory of Telecommunications Software and Multimedia
//
//Author:
//      Jari Katajavuori
//      Sami Raatikainen (based on version 1.22)
//
//Description:
//
//
//Copyright:
//
//
//Licence:
//
//
//History: 

#include "unicoordstate.h"
#include "pf/error.h"
#include "pf/protocol.h"
#include "pf/debug.h"
#include "protocol/uni/unidefs.h"
#include "protocol/uni/unistrings.h"
#include "protocol/uni/unicoordprotocol.h"
#include "uniexceptions.h"
#include "protocol/uni/unierrorinfo.h"

uniCoOrdState :: uniCoOrdState(void)
    : uniUpRSNandRRNInputs(),
      uniDownRSNInputs(),
      uniDownRRNInputs(),
      uniMessageInputs(),
      uniRSNMessageInputs(),
      uniRRNMessageInputs(),
      uaalUpInputs(),
      pfState()
{
    return;
}

uniCoOrdState :: ~uniCoOrdState(void)
{
    return;
}

void uniCoOrdState :: uniRESET_ERRORindAct(uniRESET_ERRORind *,
                                           pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniRESETconfAct(uniRESETconf *,
                                      pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniRESETindAct(uniRESETind *,
                                     pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniRESETreqAct(uniRESETreq *,
                                     pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniRESETrespAct(uniRESETresp *,
                                      pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniRESET_ERRORrespAct(uniRESET_ERRORresp *,
                                            pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniLINK_ESTABLISHreqAct(uniLINK_ESTABLISHreq *,
                                              pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniLINK_RELEASEreqAct(uniLINK_RELEASEreq *,
                                            pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniSETUPpduAct(uniSETUPpdu *,
                                     pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniCALL_PROCEEDINGpduAct(uniCALL_PROCEEDINGpdu *,
                                               pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniALERTINGpduAct(uniALERTINGpdu *,
                                        pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniCONNECTpduAct(uniCONNECTpdu *,
                                       pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniCONNECT_ACKpduAct(uniCONNECT_ACKpdu *,
                                           pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniRELEASEpduAct(uniRELEASEpdu *,
                                       pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniRELEASE_COMPLETEpduAct(uniRELEASE_COMPLETEpdu *,
                                                pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniNOTIFYpduAct(uniNOTIFYpdu *,
                                      pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniSTATUSpduAct(uniSTATUSpdu *,
                                      pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniSTATUS_ENQUIRYpduAct(uniSTATUS_ENQUIRYpdu *,
                                              pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniRESTARTpduAct(uniRESTARTpdu *,
                                       pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniRESTART_ACKpduAct(uniRESTART_ACKpdu *,
                                           pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniADD_PARTYpduAct(uniADD_PARTYpdu *,
                                         pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniADD_PARTY_ACKpduAct(uniADD_PARTY_ACKpdu *,
                                             pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniADD_PARTY_REJECTpduAct(uniADD_PARTY_REJECTpdu *,
                                                pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniDROP_PARTYpduAct(uniDROP_PARTYpdu *,
                                          pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniDROP_PARTY_ACKpduAct(uniDROP_PARTY_ACKpdu *,
                                              pfProtocol *)
{
    return;
}

void uniCoOrdState :: uaalESTABLISHindAct(uaalESTABLISHind *,
                                          pfProtocol *)
{
    return;
}

void uniCoOrdState :: uaalESTABLISHconfAct(uaalESTABLISHconf *,
                                           pfProtocol *)
{
    return;
}

void uniCoOrdState :: uaalRELEASEindAct(uaalRELEASEind *,
                                        pfProtocol *)
{
    return;
}

void uniCoOrdState :: uaalRELEASEconfAct(uaalRELEASEconf *,
                                         pfProtocol *)
{
    return;
}

void uniCoOrdState :: uaalDATAindAct(uaalDATAind *,
                                     pfProtocol *)
{
    return;
}

void uniCoOrdState :: uaalUNITDATAindAct(uaalUNITDATAind *,
                                         pfProtocol *)
{
    return;
}

void uniCoOrdState :: uniT309timeoutAct(pfProtocol *)
{
    return;
}

//--------------------------------------------------------------------

uniCoOrdAALConnectionReleased *uniCoOrdAALConnectionReleased :: _only = 0;

uniCoOrdAALConnectionReleased *uniCoOrdAALConnectionReleased :: instance(void)
{
    if (_only == 0)
    {
        _only = new uniCoOrdAALConnectionReleased;
    }
    return _only;
}

uniCoOrdAALConnectionReleased :: uniCoOrdAALConnectionReleased(void)
    : uniCoOrdState()
{
    return;
}

uniCoOrdAALConnectionReleased :: ~uniCoOrdAALConnectionReleased(void)
{
    _only = 0;
    return;
}

void uniCoOrdAALConnectionReleased :: uniRESETreqAct(
    uniRESETreq *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendRESETreqToRSN(message_); 
    protocol->sendESTABLISHreqToAAL(); 
    if (protocol->isTimerActive(uniT309Str) == 0)
    {
        protocol->startTimer(uniT309Str);
    }
    protocol->changeToAALAwaitingEstablishState();
    return;
}

void uniCoOrdAALConnectionReleased :: uniLINK_ESTABLISHreqAct(
    uniLINK_ESTABLISHreq *,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendESTABLISHreqToAAL();
    if (protocol->isTimerActive(uniT309Str) == 0)
    {
        protocol->startTimer(uniT309Str);
    }
    protocol->changeToAALAwaitingEstablishState();
    return;
}

void uniCoOrdAALConnectionReleased :: uniSETUPpduAct(
    uniSETUPpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendESTABLISHreqToAAL();
    if (protocol->isTimerActive(uniT309Str) == 0)
    {
        protocol->startTimer(uniT309Str);
    }
    protocol->changeToAALAwaitingEstablishState();
    protocol->saveMessage(message_);
    return;
}

void uniCoOrdAALConnectionReleased :: uaalESTABLISHindAct(
    uaalESTABLISHind *,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendLINK_ESTABLISHindToUNI();
    protocol->changeToAALConnectionEstablishedState();
    return;
}

void uniCoOrdAALConnectionReleased :: uniT309timeoutAct(
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendLINK_ESTABLISHerrorToUNI();
    return;
}

//--------------------------------------------------------------------

uniCoOrdAALAwaitingEstablish *uniCoOrdAALAwaitingEstablish :: _only = 0;

uniCoOrdAALAwaitingEstablish *uniCoOrdAALAwaitingEstablish :: instance(void)
{
    if (_only == 0)
    {
        _only = new uniCoOrdAALAwaitingEstablish;
    }
    return _only;
}

uniCoOrdAALAwaitingEstablish :: uniCoOrdAALAwaitingEstablish(void)
    : uniCoOrdState()
{
    return;
}

uniCoOrdAALAwaitingEstablish :: ~uniCoOrdAALAwaitingEstablish(void)
{
    _only = 0;
    return;
}

void uniCoOrdAALAwaitingEstablish :: uniSETUPpduAct(
    uniSETUPpdu *message_,
    pfProtocol *protocol_)
{
    saveMessage(message_, protocol_);
    return;
}

void uniCoOrdAALAwaitingEstablish :: uniCALL_PROCEEDINGpduAct(
    uniCALL_PROCEEDINGpdu *message_,
    pfProtocol *protocol_)
{
    saveMessage(message_, protocol_);
    return;
}

void uniCoOrdAALAwaitingEstablish :: uniCONNECTpduAct(
    uniCONNECTpdu *message_,
    pfProtocol *protocol_)
{
    saveMessage(message_, protocol_);
    return;
}

void uniCoOrdAALAwaitingEstablish :: uniCONNECT_ACKpduAct(
    uniCONNECT_ACKpdu *message_,
    pfProtocol *protocol_)
{
    saveMessage(message_, protocol_);
    return;
}

void uniCoOrdAALAwaitingEstablish :: uniRELEASEpduAct(
    uniRELEASEpdu *message_,
    pfProtocol *protocol_)
{
    saveMessage(message_, protocol_);
    return;
}

void uniCoOrdAALAwaitingEstablish :: uniRELEASE_COMPLETEpduAct(
    uniRELEASE_COMPLETEpdu *message_,
    pfProtocol *protocol_)
{
    saveMessage(message_, protocol_);
    return;
}

void uniCoOrdAALAwaitingEstablish :: uniSTATUSpduAct(
    uniSTATUSpdu *message_,
    pfProtocol *protocol_)
{
    saveMessage(message_, protocol_);
    return;
}

void uniCoOrdAALAwaitingEstablish :: uniSTATUS_ENQUIRYpduAct(
    uniSTATUS_ENQUIRYpdu *message_,
    pfProtocol *protocol_)
{
    saveMessage(message_, protocol_);
    return;
}

void uniCoOrdAALAwaitingEstablish :: uniRESTARTpduAct(
    uniRESTARTpdu *message_,
    pfProtocol *protocol_)
{
    saveMessage(message_, protocol_);
    return;
}

void uniCoOrdAALAwaitingEstablish :: uniRESTART_ACKpduAct(
    uniRESTART_ACKpdu *message_,
    pfProtocol *protocol_)
{
    saveMessage(message_, protocol_);
    return;
}

void uniCoOrdAALAwaitingEstablish :: uaalESTABLISHconfAct(
    uaalESTABLISHconf *,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);    
    protocol->stopTimer(uniT309Str);
    protocol->sendLINK_ESTABLISHconfToUNI();
    protocol->changeToAALConnectionEstablishedState();
    protocol->acceptSavedMessages();
    return;
}

void uniCoOrdAALAwaitingEstablish :: uaalRELEASEindAct(
    uaalRELEASEind *,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);    
    protocol->sendLINK_RELEASEindToUNI();
// ++TODO++ should you call removeSavedMessage here too? Yes, the second
// question remains.
// and in other places where you go released state too?
    protocol->removeSavedMessages();
    protocol->changeToAALConnectionReleasedState();
    return;
}

void uniCoOrdAALAwaitingEstablish :: uniT309timeoutAct(
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);    
    protocol->sendLINK_ESTABLISHerrorToUNI();
    protocol->removeSavedMessages();
    protocol->changeToAALConnectionReleasedState();
    return;
}

void uniCoOrdAALAwaitingEstablish :: saveMessage(pfMessenger *message_,
                                                 pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);    
    protocol->saveMessage(message_);
    return;
}

//--------------------------------------------------------------------

uniCoOrdAALAwaitingRelease *uniCoOrdAALAwaitingRelease :: _only = 0;

uniCoOrdAALAwaitingRelease *uniCoOrdAALAwaitingRelease :: instance(void)
{
    if (_only == 0)
    {
        _only = new uniCoOrdAALAwaitingRelease;
    }
    return _only;
}

uniCoOrdAALAwaitingRelease :: uniCoOrdAALAwaitingRelease(void)
    : uniCoOrdState()
{
    return;
}

uniCoOrdAALAwaitingRelease :: ~uniCoOrdAALAwaitingRelease(void)
{
    _only = 0;
    return;
}

void uniCoOrdAALAwaitingRelease :: uaalRELEASEconfAct(
    uaalRELEASEconf *,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendLINK_RELEASEconfToUNI();
    protocol->changeToAALConnectionReleasedState();
    return;
}

//--------------------------------------------------------------------

uniCoOrdAALConnectionEstablished *
uniCoOrdAALConnectionEstablished :: _only = 0;

uniCoOrdAALConnectionEstablished *
uniCoOrdAALConnectionEstablished :: instance(void)
{
    if (_only == 0)
    {
        _only = new uniCoOrdAALConnectionEstablished;
    }
    return _only;
}

uniCoOrdAALConnectionEstablished :: uniCoOrdAALConnectionEstablished(void)
    : uniCoOrdState()
{
    return;
}

uniCoOrdAALConnectionEstablished :: ~uniCoOrdAALConnectionEstablished(void)
{
    _only = 0;
    return;
}

void uniCoOrdAALConnectionEstablished :: uniRESET_ERRORindAct(
    uniRESET_ERRORind *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendRESET_ERRORindToUNI(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniRESETconfAct(
    uniRESETconf *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendRESETconfToUNI(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniRESETindAct(
    uniRESETind *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendRESETindToUNI(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniRESETreqAct(
    uniRESETreq *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendRESETreqToRSN(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniRESETrespAct(
    uniRESETresp *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendRESETrespToRRN(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniRESET_ERRORrespAct(
    uniRESET_ERRORresp *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendRESET_ERRORrespToRRN(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniLINK_RELEASEreqAct(
    uniLINK_RELEASEreq *,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendRELEASEreqToAAL();
    protocol->changeToAALAwaitingReleaseState();
    return;
}

void uniCoOrdAALConnectionEstablished :: uniLINK_ESTABLISHreqAct(
    uniLINK_ESTABLISHreq *,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendLINK_ESTABLISHconfToUNI();
    return;
}

void uniCoOrdAALConnectionEstablished :: uaalRELEASEindAct(
    uaalRELEASEind *,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendLINK_RELEASEindToUNI();
    protocol->changeToAALConnectionReleasedState();
    return;
}

void uniCoOrdAALConnectionEstablished :: uaalESTABLISHindAct(
    uaalESTABLISHind *,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendLINK_ESTABLISHindToUNI();
    return;
}

void uniCoOrdAALConnectionEstablished :: uaalESTABLISHconfAct(
    uaalESTABLISHconf *,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendLINK_ESTABLISHconfToUNI();
    return;
}

//
// Method: uaalDATAindAct
//
// Description:
//     This is called whenever data has been received. Procedures for
//     the message is determined from the call reference contents
//     (dummy, global, reserved or free)
//

void uniCoOrdAALConnectionEstablished :: uaalDATAindAct(
    uaalDATAind *message_,
    pfProtocol *protocol_)
{
    debugUser("UAAL DATA ind");
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    THROW_IF_DYNAMIC_CAST_FAILED(protocol);
    
    pfFrame frame = message_->getMessageUnit();
    uniPdu *pdu = 0;
    // pfMessenger *msg = 0;
    
    try
    {
        pdu = uniPdu::create(frame, protocol);
        // msg = uniPduCoder::create(frame, protocol);

        pfUlong callReference = pdu->getInteger(uniCallReferenceStr);
        
        if (callReference == uniGlobalCallReference)
        {
             debugUser("uniCoOrdAALConnectionEstablished::uaalDATAindAct globalCallReferenceProcedures");
             pdu->globalCallReferenceProcedures(protocol);
        }
        else if (callReference != uniDummyCallReference)
        {
            pfUlong muxReference = pdu->getInteger(uniMuxReferenceStr);
            if (protocol->isMuxKeyAllocated(muxReference) == 0)
            {
                debugUser("uniCoOrdAALConnectionEstablished::uaalDATAindAct noProtocolCallReferenceProcedures");
                pdu->noProtocolCallReferenceProcedures(protocol);
            }
            else
            {
                debugUser("uniCoOrdAALConnectionEstablished::uaalDATAindAct protocolRelatedCallReferenceProcedures");
                pdu->protocolRelatedCallReferenceProcedures(protocol);
            }
        }
    }
    catch (uniDiscardMessageException &)
    {
        debugExceptionCatched(0);               
    }
    catch (pfException &exception)
    {
        pfUlong cause = exception.getCause();
        debugExceptionCatched(cause);
        debugUser("Sending status reply...");        
        uniErrorInfo errorInfo(cause);
        protocol->sendSTATUSreplyToAAL(errorInfo);
    }

    return;
}

void uniCoOrdAALConnectionEstablished :: uniSETUPpduAct(
    uniSETUPpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniCALL_PROCEEDINGpduAct(
    uniCALL_PROCEEDINGpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniALERTINGpduAct(
    uniALERTINGpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniCONNECTpduAct(
    uniCONNECTpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniCONNECT_ACKpduAct(
    uniCONNECT_ACKpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniRELEASEpduAct(
    uniRELEASEpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniRELEASE_COMPLETEpduAct(
    uniRELEASE_COMPLETEpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniNOTIFYpduAct(
    uniNOTIFYpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniSTATUSpduAct(
    uniSTATUSpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniSTATUS_ENQUIRYpduAct(
    uniSTATUS_ENQUIRYpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniRESTARTpduAct(
    uniRESTARTpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniRESTART_ACKpduAct(
    uniRESTART_ACKpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniADD_PARTYpduAct(
    uniADD_PARTYpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniADD_PARTY_ACKpduAct(
    uniADD_PARTY_ACKpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniADD_PARTY_REJECTpduAct(
    uniADD_PARTY_REJECTpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniDROP_PARTYpduAct(
    uniDROP_PARTYpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}

void uniCoOrdAALConnectionEstablished :: uniDROP_PARTY_ACKpduAct(
    uniDROP_PARTY_ACKpdu *message_,
    pfProtocol *protocol_)
{
    uniCoOrdProtocol *protocol = dynamic_cast<uniCoOrdProtocol*>(protocol_);
    protocol->sendDATAreqToAAL(message_);
    return;
}