//Editor-Info: -*- C++ -*-
//
//Subject: TOVE project / UNI
//
//File: uniprimitives.cpp
//
//Version: $Revision: 1.12 $
//
//State: $State: Exp $
//
//Date: $Date: 1998/12/14 06:56:32 $
//
//Organisation:
//      Helsinki University of Technology
//      Laboratory of Telecommunications Software and Multimedia
//
//Author:
//      Jari Katajavuori
//
//Description:
//      Primitives for internal use of uni module.
//
//Copyright:
//
//
//Licence:
//
//
//History: 

#include "uniprimitives.h"

#include "pf/state.h"
#include "pf/protocol.h"

#include "unistrings.h"

//--------------------------------------------------------------------
// Primitive: uniRESET_ERRORind
// Direction: up
// Destination: UNI

uniRESET_ERRORind :: uniRESET_ERRORind(void)
    : pfMessenger()
{
    return;
}

uniRESET_ERRORind :: uniRESET_ERRORind(const uniRESET_ERRORind &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniRESET_ERRORind :: clone(void)
{
    pfMessenger *primitive = new uniRESET_ERRORind(*this);
    return primitive;
}

uniRESET_ERRORind *uniRESET_ERRORind :: create(pfUlong reason_,
                                               pfUlong callState_)
{
    uniRESET_ERRORind *primitive = new uniRESET_ERRORind;
    primitive->defineInteger(uniReasonStr);
    primitive->defineInteger(uniCallStateStr);
    primitive->setInteger(uniReasonStr, reason_);
    primitive->setInteger(uniCallStateStr, callState_);
    return primitive;
}

void uniRESET_ERRORind :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniUpRSNandRRNInputs *upInput =
        dynamic_cast<uniUpRSNandRRNInputs*>(state_);

    upInput->uniRESET_ERRORindAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniRESETconf
// Direction: up
// Destination: UNI

uniRESETconf :: uniRESETconf(void)
    : pfMessenger()
{
    return;
}

uniRESETconf :: uniRESETconf(const uniRESETconf &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniRESETconf :: clone(void)
{
    pfMessenger *primitive = new uniRESETconf(*this);
    return primitive;
}

uniRESETconf *uniRESETconf :: create(void)
{
    uniRESETconf *primitive = new uniRESETconf;
    return primitive;
}

void uniRESETconf :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniUpRSNandRRNInputs *upInput =
        dynamic_cast<uniUpRSNandRRNInputs*>(state_);

    upInput->uniRESETconfAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniRESETind
// Direction: up
// Destination: UNI

uniRESETind :: uniRESETind(void)
    : pfMessenger()
{
    return;
}

uniRESETind :: uniRESETind(const uniRESETind &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniRESETind :: clone(void)
{
    pfMessenger *primitive = new uniRESETind(*this);
    return primitive;
}

uniRESETind *uniRESETind :: create(void)
{
    uniRESETind *primitive = new uniRESETind;
    return primitive;
}

void uniRESETind :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniUpRSNandRRNInputs *upInput =
        dynamic_cast<uniUpRSNandRRNInputs*>(state_);

    upInput->uniRESETindAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniRESETreq
// Direction: down
// Destination: RSN

uniRESETreq :: uniRESETreq(void)
    : pfMessenger()
{
    return;
}

uniRESETreq :: uniRESETreq(const uniRESETreq &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniRESETreq :: clone(void)
{
    pfMessenger *primitive = new uniRESETreq(*this);
    return primitive;
}

uniRESETreq *uniRESETreq :: create(void)
{
    uniRESETreq *primitive = new uniRESETreq;
    return primitive;
}

void uniRESETreq :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniDownRSNInputs *RSNinput = dynamic_cast<uniDownRSNInputs*>(state_);

    RSNinput->uniRESETreqAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniRESETresp
// Direction: down
// Destination: RRN

uniRESETresp :: uniRESETresp(void)
    : pfMessenger()
{
    return;
}

uniRESETresp :: uniRESETresp(const uniRESETresp &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniRESETresp :: clone(void)
{
    pfMessenger *primitive = new uniRESETresp(*this);
    return primitive;
}

uniRESETresp *uniRESETresp :: create(void)
{
    uniRESETresp *primitive = new uniRESETresp;
    return primitive;
}

void uniRESETresp :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniDownRRNInputs *RRNinput = dynamic_cast<uniDownRRNInputs*>(state_);

    RRNinput->uniRESETrespAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniRESET_ERRORresp
// Direction: down
// Destination: RRN

uniRESET_ERRORresp :: uniRESET_ERRORresp(void)
    : pfMessenger()
{
    return;
}

uniRESET_ERRORresp :: uniRESET_ERRORresp(const uniRESET_ERRORresp &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniRESET_ERRORresp :: clone(void)
{
    pfMessenger *primitive = new uniRESET_ERRORresp(*this);
    return primitive;
}

uniRESET_ERRORresp *uniRESET_ERRORresp :: create(void)
{
    uniRESET_ERRORresp *primitive = new uniRESET_ERRORresp;
    return primitive;
}

void uniRESET_ERRORresp :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniDownRRNInputs *RRNinput = dynamic_cast<uniDownRRNInputs*>(state_);

    RRNinput->uniRESET_ERRORrespAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniLINK_ESTABLISHreq
// Direction: down
// Destination: Coord

uniLINK_ESTABLISHreq :: uniLINK_ESTABLISHreq(void)
    : pfMessenger()
{
    return;
}

uniLINK_ESTABLISHreq :: uniLINK_ESTABLISHreq(
    const uniLINK_ESTABLISHreq &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniLINK_ESTABLISHreq :: clone(void)
{
    pfMessenger *primitive = new uniLINK_ESTABLISHreq(*this);
    return primitive;
}

uniLINK_ESTABLISHreq *uniLINK_ESTABLISHreq :: create(void)
{
    uniLINK_ESTABLISHreq *primitive = new uniLINK_ESTABLISHreq;
    return primitive;
}

void uniLINK_ESTABLISHreq :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniDownInputs *downInput = dynamic_cast<uniDownInputs*>(state_);

    downInput->uniLINK_ESTABLISHreqAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniLINK_RELEASEreq
// Direction: down
// Destination: Coord

uniLINK_RELEASEreq :: uniLINK_RELEASEreq(void)
    : pfMessenger()
{
    return;
}

uniLINK_RELEASEreq :: uniLINK_RELEASEreq(const uniLINK_RELEASEreq &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniLINK_RELEASEreq :: clone(void)
{
    pfMessenger *primitive = new uniLINK_RELEASEreq(*this);
    return primitive;
}

uniLINK_RELEASEreq *uniLINK_RELEASEreq :: create(void)
{
    uniLINK_RELEASEreq *primitive = new uniLINK_RELEASEreq;
    return primitive;
}

void uniLINK_RELEASEreq :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniDownInputs *downInput = dynamic_cast<uniDownInputs*>(state_);

    downInput->uniLINK_RELEASEreqAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniLINK_ESTABLISHconf
// Direction: up
// Destination: UNI

uniLINK_ESTABLISHconf :: uniLINK_ESTABLISHconf(void)
    : pfMessenger()
{
    return;
}

uniLINK_ESTABLISHconf :: uniLINK_ESTABLISHconf(
    const uniLINK_ESTABLISHconf &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniLINK_ESTABLISHconf :: clone(void)
{
    pfMessenger *primitive = new uniLINK_ESTABLISHconf(*this);
    return primitive;
}

uniLINK_ESTABLISHconf *uniLINK_ESTABLISHconf :: create(void)
{
    uniLINK_ESTABLISHconf *primitive = new uniLINK_ESTABLISHconf;
    return primitive;
}

void uniLINK_ESTABLISHconf :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniUpInputs *upInput = dynamic_cast<uniUpInputs*>(state_);

    upInput->uniLINK_ESTABLISHconfAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniLINK_ESTABLISHind
// Direction: up
// Destination: UNI

uniLINK_ESTABLISHind :: uniLINK_ESTABLISHind(void)
    : pfMessenger()
{
    return;
}

uniLINK_ESTABLISHind :: uniLINK_ESTABLISHind(
    const uniLINK_ESTABLISHind &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniLINK_ESTABLISHind :: clone(void)
{
    pfMessenger *primitive = new uniLINK_ESTABLISHind(*this);
    return primitive;
}

uniLINK_ESTABLISHind *uniLINK_ESTABLISHind :: create(void)
{
    uniLINK_ESTABLISHind *primitive = new uniLINK_ESTABLISHind;
    return primitive;
}

void uniLINK_ESTABLISHind :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniUpInputs *upInput = dynamic_cast<uniUpInputs*>(state_);

    upInput->uniLINK_ESTABLISHindAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniLINK_ESTABLISHerror
// Direction: up
// Destination: UNI

uniLINK_ESTABLISHerror :: uniLINK_ESTABLISHerror(void)
    : pfMessenger()
{
    return;
}

uniLINK_ESTABLISHerror :: uniLINK_ESTABLISHerror(
    const uniLINK_ESTABLISHerror &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniLINK_ESTABLISHerror :: clone(void)
{
    pfMessenger *primitive = new uniLINK_ESTABLISHerror(*this);
    return primitive;
}

uniLINK_ESTABLISHerror *uniLINK_ESTABLISHerror :: create(void)
{
    uniLINK_ESTABLISHerror *primitive = new uniLINK_ESTABLISHerror;
    return primitive;
}

void uniLINK_ESTABLISHerror :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniUpInputs *upInput = dynamic_cast<uniUpInputs*>(state_);

    upInput->uniLINK_ESTABLISHerrorAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniLINK_RELEASEconf
// Direction: up
// Destination: UNI

uniLINK_RELEASEconf :: uniLINK_RELEASEconf(void)
    : pfMessenger()
{
    return;
}

uniLINK_RELEASEconf :: uniLINK_RELEASEconf(const uniLINK_RELEASEconf &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniLINK_RELEASEconf :: clone(void)
{
    pfMessenger *primitive = new uniLINK_RELEASEconf(*this);
    return primitive;
}

uniLINK_RELEASEconf *uniLINK_RELEASEconf :: create(void)
{
    uniLINK_RELEASEconf *primitive = new uniLINK_RELEASEconf;
    return primitive;
}

void uniLINK_RELEASEconf :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniUpInputs *upInput = dynamic_cast<uniUpInputs*>(state_);

    upInput->uniLINK_RELEASEconfAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniLINK_RELEASEind
// Direction: up
// Destination: UNI

uniLINK_RELEASEind :: uniLINK_RELEASEind(void)
    : pfMessenger()
{
    return;
}

uniLINK_RELEASEind :: uniLINK_RELEASEind(
    const uniLINK_RELEASEind &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniLINK_RELEASEind :: clone(void)
{
    pfMessenger *primitive = new uniLINK_RELEASEind(*this);
    return primitive;
}

uniLINK_RELEASEind *uniLINK_RELEASEind :: create(void)
{
    uniLINK_RELEASEind *primitive = new uniLINK_RELEASEind;
    return primitive;
}

void uniLINK_RELEASEind :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniUpInputs *upInput = dynamic_cast<uniUpInputs*>(state_);

    upInput->uniLINK_RELEASEindAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniADD_PARTYreq
// Direction: up/down
// Destination: PMP/UNI

uniADD_PARTYreq :: uniADD_PARTYreq(void)
    : pfMessenger()
{
    return;
}

uniADD_PARTYreq :: uniADD_PARTYreq(
    const uniADD_PARTYreq &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniADD_PARTYreq :: clone(void)
{
    pfMessenger *primitive = new uniADD_PARTYreq(*this);
    return primitive;
}

uniADD_PARTYreq *uniADD_PARTYreq :: create(void)
{
    uniADD_PARTYreq *primitive = new uniADD_PARTYreq;
    return primitive;
}

void uniADD_PARTYreq :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniPMPInputs *input = dynamic_cast<uniPMPInputs*>(state_);
    input->uniADD_PARTYreqAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniADD_PARTYresp
// Direction: up/down
// Destination: PMP/UNI

uniADD_PARTYresp :: uniADD_PARTYresp(void)
    : pfMessenger()
{
    return;
}

uniADD_PARTYresp :: uniADD_PARTYresp(
    const uniADD_PARTYresp &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniADD_PARTYresp :: clone(void)
{
    pfMessenger *primitive = new uniADD_PARTYresp(*this);
    return primitive;
}

uniADD_PARTYresp *uniADD_PARTYresp :: create(void)
{
    uniADD_PARTYresp *primitive = new uniADD_PARTYresp;
    return primitive;
}

void uniADD_PARTYresp :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniPMPInputs *input = dynamic_cast<uniPMPInputs*>(state_);
    input->uniADD_PARTYrespAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniADD_PARTYerror
// Direction: up/down
// Destination: PMP/UNI

uniADD_PARTYerror :: uniADD_PARTYerror(void)
    : pfMessenger()
{
    return;
}

uniADD_PARTYerror :: uniADD_PARTYerror(
    const uniADD_PARTYerror &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniADD_PARTYerror :: clone(void)
{
    pfMessenger *primitive = new uniADD_PARTYerror(*this);
    return primitive;
}

uniADD_PARTYerror *uniADD_PARTYerror :: create(void)
{
    uniADD_PARTYerror *primitive = new uniADD_PARTYerror;
    return primitive;
}

void uniADD_PARTYerror :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniPMPInputs *input = dynamic_cast<uniPMPInputs*>(state_);
    input->uniADD_PARTYerrorAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniDROP_PARTYreq
// Direction: up/down
// Destination: PMP/UNI

uniDROP_PARTYreq :: uniDROP_PARTYreq(void)
    : pfMessenger()
{
    return;
}

uniDROP_PARTYreq :: uniDROP_PARTYreq(
    const uniDROP_PARTYreq &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniDROP_PARTYreq :: clone(void)
{
    pfMessenger *primitive = new uniDROP_PARTYreq(*this);
    return primitive;
}

uniDROP_PARTYreq *uniDROP_PARTYreq :: create(void)
{
    uniDROP_PARTYreq *primitive = new uniDROP_PARTYreq;
    return primitive;
}

void uniDROP_PARTYreq :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniPMPInputs *input = dynamic_cast<uniPMPInputs*>(state_);
    input->uniDROP_PARTYreqAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniDROP_PARTYresp
// Direction: up/down
// Destination: PMP/UNI

uniDROP_PARTYresp :: uniDROP_PARTYresp(void)
    : pfMessenger()
{
    return;
}

uniDROP_PARTYresp :: uniDROP_PARTYresp(
    const uniDROP_PARTYresp &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniDROP_PARTYresp :: clone(void)
{
    pfMessenger *primitive = new uniDROP_PARTYresp(*this);
    return primitive;
}

uniDROP_PARTYresp *uniDROP_PARTYresp :: create(void)
{
    uniDROP_PARTYresp *primitive = new uniDROP_PARTYresp;
    return primitive;
}

void uniDROP_PARTYresp :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniPMPInputs *input = dynamic_cast<uniPMPInputs*>(state_);
    input->uniDROP_PARTYrespAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniSTATUSreq
// Direction: up/down
// Destination: PMP/UNI

uniSTATUSreq :: uniSTATUSreq(void)
    : pfMessenger()
{
    return;
}

uniSTATUSreq :: uniSTATUSreq(
    const uniSTATUSreq &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniSTATUSreq :: clone(void)
{
    pfMessenger *primitive = new uniSTATUSreq(*this);
    return primitive;
}

uniSTATUSreq *uniSTATUSreq :: create(void)
{
    uniSTATUSreq *primitive = new uniSTATUSreq;
    return primitive;
}

void uniSTATUSreq :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniPMPInputs *input = dynamic_cast<uniPMPInputs*>(state_);
    input->uniSTATUSreqAct(this, protocol_);
    return;
}

//--------------------------------------------------------------------
// Primitive: uniSTATUSresp
// Direction: up/down
// Destination: PMP/UNI

uniSTATUSresp :: uniSTATUSresp(void)
    : pfMessenger()
{
    return;
}

uniSTATUSresp :: uniSTATUSresp(
    const uniSTATUSresp &other_)
    : pfMessenger(other_)
{
    return;
}

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

pfMessenger *uniSTATUSresp :: clone(void)
{
    pfMessenger *primitive = new uniSTATUSresp(*this);
    return primitive;
}

uniSTATUSresp *uniSTATUSresp :: create(void)
{
    uniSTATUSresp *primitive = new uniSTATUSresp;
    return primitive;
}

void uniSTATUSresp :: apply(pfState *state_, pfProtocol *protocol_)
{
    uniPMPInputs *input = dynamic_cast<uniPMPInputs*>(state_);
    input->uniSTATUSrespAct(this, protocol_);
    return;
}