//Editor-Info: -*- C++ -*-
//
//Subject: TOVE project / SIG
//
//File: sigtimeouts.cpp
//
//Version: $Revision: 1.1 $
//
//State: $State: Exp $
//
//Date: $Date: 1998/11/11 13:30:52 $
//
//Organisation:
//      Helsinki University of Technology
//      Laboratory of Telecommunications Software and Multimedia
//
//Author:
//      Sami Raatikainen
//
//Description:
//      See the corresponding header file.
//
//Copyright:
//
//
//Licence:
//
//
//History: 

#include "sigtimeouts.h"

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

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

pfTimerMessenger *sigAwaitCONNECTtimeout :: create(void)
{
    sigAwaitCONNECTtimeout *messenger = new sigAwaitCONNECTtimeout;
    return messenger;
}

sigAwaitCONNECTtimeout :: sigAwaitCONNECTtimeout(void)
    : pfTimerMessenger()
{
    return;
}

sigAwaitCONNECTtimeout :: sigAwaitCONNECTtimeout(
    const sigAwaitCONNECTtimeout &other_)
    : pfTimerMessenger(other_)
{
    return;
}

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

pfTimerMessenger *sigAwaitCONNECTtimeout :: clone(void) const
{
    sigAwaitCONNECTtimeout *messenger = new sigAwaitCONNECTtimeout(*this);
    return messenger;
}

void sigAwaitCONNECTtimeout :: apply(pfState *state_, pfProtocol *protocol_)
{
    sigTimeoutInputs *input = dynamic_cast<sigTimeoutInputs*>(state_);
    input->sigAwaitCONNECTtimeoutAct(protocol_);
    return;
}


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

pfTimerMessenger *sigAwaitPROCEEDINGtimeout :: create(void)
{
    sigAwaitPROCEEDINGtimeout *messenger = new sigAwaitPROCEEDINGtimeout;
    return messenger;
}

sigAwaitPROCEEDINGtimeout :: sigAwaitPROCEEDINGtimeout(void)
    : pfTimerMessenger()
{
    return;
}

sigAwaitPROCEEDINGtimeout :: sigAwaitPROCEEDINGtimeout(
    const sigAwaitPROCEEDINGtimeout &other_)
    : pfTimerMessenger(other_)
{
    return;
}

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

pfTimerMessenger *sigAwaitPROCEEDINGtimeout :: clone(void) const
{
    sigAwaitPROCEEDINGtimeout *messenger = new sigAwaitPROCEEDINGtimeout(*this);
    return messenger;
}

void sigAwaitPROCEEDINGtimeout :: apply(pfState *state_, pfProtocol *protocol_)
{
    sigTimeoutInputs *input = dynamic_cast<sigTimeoutInputs*>(state_);
    input->sigAwaitPROCEEDINGtimeoutAct(protocol_);
    return;
}

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

pfTimerMessenger *sigAwaitRLCtimeout :: create(void)
{
    sigAwaitRLCtimeout *messenger = new sigAwaitRLCtimeout;
    return messenger;
}

sigAwaitRLCtimeout :: sigAwaitRLCtimeout(void)
    : pfTimerMessenger()
{
    return;
}

sigAwaitRLCtimeout :: sigAwaitRLCtimeout(const sigAwaitRLCtimeout &other_)
    : pfTimerMessenger(other_)
{
    return;
}

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

pfTimerMessenger *sigAwaitRLCtimeout :: clone(void) const
{
    sigAwaitRLCtimeout *messenger = new sigAwaitRLCtimeout(*this);
    return messenger;
}

void sigAwaitRLCtimeout :: apply(pfState *state_, pfProtocol *protocol_)
{
    sigTimeoutInputs *input = dynamic_cast<sigTimeoutInputs*>(state_);
    input->sigAwaitRLCtimeoutAct(protocol_);
    return;
}


// -----------------------------------------------------------
// Class: bisupT7btimeout

pfTimerMessenger *bisupT7btimeout :: create(void)
{
    bisupT7btimeout *messenger = new bisupT7btimeout;
    return messenger;
}

bisupT7btimeout :: bisupT7btimeout(void)
    : pfTimerMessenger()
{
    return;
}

bisupT7btimeout :: bisupT7btimeout(const bisupT7btimeout &other_)
    : pfTimerMessenger(other_)
{
    return;
}

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

pfTimerMessenger *bisupT7btimeout :: clone(void) const
{
    bisupT7btimeout *messenger = new bisupT7btimeout(*this);
    return messenger;
}

void bisupT7btimeout :: apply(pfState *state_, pfProtocol *protocol_)
{
    sigTimeoutInputs *input = dynamic_cast<sigTimeoutInputs*>(state_);
    input->bisupT7btimeoutAct(protocol_);
    return;
}


//
// Class: uniT310timeout
//
// Description:
//      Timer T310 is started when CALL PROCEEDING is received.
//

pfTimerMessenger *uniT310timeout :: create(void)
{
    uniT310timeout *messenger = new uniT310timeout;
    return messenger;
}

uniT310timeout :: uniT310timeout(void)
    : pfTimerMessenger()
{
    return;
}

uniT310timeout :: uniT310timeout(const uniT310timeout &other_)
    : pfTimerMessenger(other_)
{
    return;
}

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

pfTimerMessenger *uniT310timeout :: clone(void) const
{
    uniT310timeout *messenger = new uniT310timeout(*this);
    return messenger;
}

void uniT310timeout :: apply(pfState *state_, pfProtocol *protocol_)
{
    sigTimeoutInputs *input = dynamic_cast<sigTimeoutInputs*>(state_);
    input->uniT310timeoutAct(protocol_);
    return;
}

//
// Class: uniT313timeout
//
// Description:
//      Timer T313 is started when CONNECT is sent.
//

pfTimerMessenger *uniT313timeout :: create(void)
{
    uniT313timeout *messenger = new uniT313timeout;
    return messenger;
}

uniT313timeout :: uniT313timeout(void)
    : pfTimerMessenger()
{
    return;
}

uniT313timeout :: uniT313timeout(const uniT313timeout &other_)
    : pfTimerMessenger(other_)
{
    return;
}

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

pfTimerMessenger *uniT313timeout :: clone(void) const
{
    uniT313timeout *messenger = new uniT313timeout(*this);
    return messenger;
}

void uniT313timeout :: apply(pfState *state_, pfProtocol *protocol_)
{
    sigTimeoutInputs *input = dynamic_cast<sigTimeoutInputs*>(state_);
    input->uniT313timeoutAct(protocol_);
    return;
}


//
// Class: uniT322timeout
//
// Description:
//      Timer T322 is started when STATUS ENQUIRY is sent.
//

pfTimerMessenger *uniT322timeout :: create(void)
{
    uniT322timeout *messenger = new uniT322timeout;
    return messenger;
}

uniT322timeout :: uniT322timeout(void)
    : pfTimerMessenger()
{
    return;
}

uniT322timeout :: uniT322timeout(const uniT322timeout &other_)
    : pfTimerMessenger(other_)
{
    return;
}

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

pfTimerMessenger *uniT322timeout :: clone(void) const
{
    uniT322timeout *messenger = new uniT322timeout(*this);
    return messenger;
}

void uniT322timeout :: apply(pfState *state_, pfProtocol *protocol_)
{
    sigTimeoutInputs *input = dynamic_cast<sigTimeoutInputs*>(state_);
    input->uniT322timeoutAct(protocol_);
    return;
}


//
// Class: uniTREMOVEDtimeout
//
// Description:
//      Timer TREMOVED is started when ADD PARTY is sent.
//

pfTimerMessenger *uniTREMOVEDtimeout :: create(void)
{
    uniTREMOVEDtimeout *messenger = new uniTREMOVEDtimeout;
    return messenger;
}

uniTREMOVEDtimeout :: uniTREMOVEDtimeout(void)
    : pfTimerMessenger()
{
    return;
}

uniTREMOVEDtimeout :: uniTREMOVEDtimeout(const uniTREMOVEDtimeout &other_)
    : pfTimerMessenger(other_)
{
    return;
}

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

pfTimerMessenger *uniTREMOVEDtimeout :: clone(void) const
{
    uniTREMOVEDtimeout *messenger = new uniTREMOVEDtimeout(*this);
    return messenger;
}

void uniTREMOVEDtimeout :: apply(pfState *state_, pfProtocol *protocol_)
{
    sigTimeoutInputs *input = dynamic_cast<sigTimeoutInputs*>(state_);
    input->uniTREMOVEDtimeoutAct(protocol_);
    return;
}