//Editor-Info: -*- C++ -*-
//
//Subject: TOVE project / SSCOP protocol
//
//File: sscoptimeouts.cpp
//
//Version: $Revision: 1.5 $
//
//State: $State: Exp $
//
//Date: $Date: 1999/03/11 18:53:56 $
//
//Organisation:
//      Helsinki University of Technology
//      Laboratory of Telecommunications and Multimedia
//
//Author:
//      Juhana Räsänen
//
//Description:
//      See corresponding header file
//
//Copyright:
//      Copyright 1999 Helsinki University of Technology
//      ALL RIGHTS RESERVED BETWEEN JANUARY 1996 AND JUNE 1999.
//
//Licence:
//
//
//History: 


#include <assert.h>
#include "sscoptimeouts.h"
#include "sscopstate.h"
#include "pf/error.h"

//
// Functions: SSCOP timeout messenger member functions
//
// Description:
//     Member functions that are needed to implement OVOPS++ timer
//     messenger functionality. See pfTimer documentation for more
//     information.
//

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

sscopCCtimeout :: sscopCCtimeout(const sscopCCtimeout &)
    : pfTimerMessenger()
{
    return;
}

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

pfTimerMessenger *sscopCCtimeout :: clone(void) const
{
    pfTimerMessenger *messenger = new sscopCCtimeout(*this);
    assert(messenger != 0);
    return messenger;
}

void sscopCCtimeout :: apply(pfState *state_, pfProtocol *protocol_)
{
    sscopState *state = dynamic_cast<sscopState *>(state_);
    THROW_IF_DYNAMIC_CAST_FAILED(state);
    state->sscopCCtimeoutAct((sscopProtocol *) protocol_);
    return;
}


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


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

sscopKEEP_ALIVEtimeout :: sscopKEEP_ALIVEtimeout(
    const sscopKEEP_ALIVEtimeout &)
    : pfTimerMessenger()
{
    return;
}

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

pfTimerMessenger *sscopKEEP_ALIVEtimeout :: clone(void) const
{
    pfTimerMessenger *messenger = new sscopKEEP_ALIVEtimeout(*this);
    assert(messenger != 0);
    return messenger;
}

void sscopKEEP_ALIVEtimeout :: apply(
    pfState *state_,
    pfProtocol *protocol_)
{
    sscopState *state = dynamic_cast<sscopState *>(state_);
    THROW_IF_DYNAMIC_CAST_FAILED(state);
    state->sscopKEEPALIVEtimeoutAct((sscopProtocol *) protocol_);
    return;
}


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


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

sscopNO_RESPONSEtimeout :: sscopNO_RESPONSEtimeout(
    const sscopNO_RESPONSEtimeout &)
    : pfTimerMessenger()
{
    return;
}

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

pfTimerMessenger *sscopNO_RESPONSEtimeout :: clone(void) const
{
    pfTimerMessenger *messenger = new sscopNO_RESPONSEtimeout(*this);
    assert(messenger != 0);
    return messenger;
}

void sscopNO_RESPONSEtimeout :: apply(
    pfState *state_,
    pfProtocol *protocol_)
{
    sscopState *state = dynamic_cast<sscopState *>(state_);
    THROW_IF_DYNAMIC_CAST_FAILED(state);
    state->sscopNORESPONSEtimeoutAct((sscopProtocol *) protocol_);
    return;
}


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


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

sscopPOLLtimeout :: sscopPOLLtimeout(const sscopPOLLtimeout &)
    : pfTimerMessenger()
{
    return;
}

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

pfTimerMessenger *sscopPOLLtimeout :: clone(void) const
{
    pfTimerMessenger *messenger = new sscopPOLLtimeout(*this);
    assert(messenger != 0);
    return messenger;
}

void sscopPOLLtimeout :: apply(pfState *state_, pfProtocol *protocol_)
{
    sscopState *state = dynamic_cast<sscopState *>(state_);
    THROW_IF_DYNAMIC_CAST_FAILED(state);
    state->sscopPOLLtimeoutAct((sscopProtocol *) protocol_);
    return;
}


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


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

sscopIDLEtimeout :: sscopIDLEtimeout(const sscopIDLEtimeout &)
    : pfTimerMessenger()
{
    return;
}

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

pfTimerMessenger *sscopIDLEtimeout :: clone(void) const
{
    pfTimerMessenger *messenger = new sscopIDLEtimeout(*this);
    assert(messenger != 0);
    return messenger;
}

void sscopIDLEtimeout :: apply(pfState *state_, pfProtocol *protocol_)
{
    sscopState *state = dynamic_cast<sscopState *>(state_);
    THROW_IF_DYNAMIC_CAST_FAILED(state);
    state->sscopIDLEtimeoutAct((sscopProtocol *) protocol_);
    return;
}