//Editor-Info: -*- C++ -*-
//
//Subject: GSMP
//
//File: gsmpeventmessages.cpp
//
//Version: $Revision: 1.7 $
//
//State: $State: Exp $
//
//Date: $Date: 1998/12/16 16:57:24 $
//
//Organisation:
//      Helsinki University of Technology
//      Laboratory of Telecommunications Software and Multimedia
//
//Author:
//      Harri Sunila
//
//Description:
//      See corresponding header file
//
//Copyright:
//      Copyright 1999 Helsinki University of Technology
//      ALL RIGHTS RESERVED BETWEEN JANUARY 1996 AND JUNE 1999.
//      
//Licence:
//     
//
//History:
//

#include "gsmpeventmessages.h"
#include "gsmpprotocolstate.h"
#include "gsmpexceptions.h"
#include "pf/error.h"

//
// Function: gsmpEventMessage
// 
// Description:
//     Default constructor
//

gsmpEventMessage :: gsmpEventMessage(void)
    : gsmpMessage(),
      _port(0),
      _portSessionNumber(0),
      _eventSequenceNumber(0),
      _VPI(0),
      _VCI(0)
{
    return;
}

//
// Function: gsmpEventMessage
// 
// Description:
//     Copy constructor
//

gsmpEventMessage :: gsmpEventMessage(const gsmpEventMessage &other_)
    : gsmpMessage(other_),
      _port(other_._port),
      _portSessionNumber(other_._portSessionNumber),
      _eventSequenceNumber(other_._eventSequenceNumber),
      _VPI(other_._VPI),
      _VCI(other_._VCI)
{
    return;
}


//
// Function: ~gsmpEventMessage
// 
// Description:
//     Destructor
//

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

//
// Function: encodeFrame
// 
// Description:
//     This method encodes a GSMP event message to a frame 
//

pfFrame gsmpEventMessage :: encodeFrame(void)
{
    _frame.clear();
    _frame.putLast(_version);
    _frame.putLast(_messageType);
    _frame.putLast(_result);
    _frame.putLast(_code);
    _frame.putLast32bit(_transactionIdentifier);
    _frame.putLast32bit(_port);
    _frame.putLast32bit(_portSessionNumber);
    _frame.putLast32bit(_eventSequenceNumber);
    _frame.putLast16bit(_VPI & gsmpMessage::GSMP_VPI_MASK);
    _frame.putLast16bit(_VCI);
    return _frame;
}
    
//
// Function: decodeFrame
// 
// Description:
//

void gsmpEventMessage :: decodeFrame(pfFrame &frame_)
{
    _frame = frame_;
    _version = frame_.getFirst();
    _messageType = frame_.getFirst();
    _result = frame_.getFirst();
    _code = frame_.getFirst();
    _transactionIdentifier = frame_.getFirst32bit();
    _port = frame_.getFirst32bit();
    _portSessionNumber = frame_.getFirst32bit();
    _eventSequenceNumber = frame_.getFirst32bit();
    _VPI = (frame_.getFirst16bit() & gsmpMessage::GSMP_VPI_MASK);
    _VCI = frame_.getFirst16bit();
    if (frame_.length() != 0)
    {
        throw gsmpInvalidLengthException(PF_EX_INFO);
    }
    return;
}

//
// Functions: Get
// 
// Description:
//     These methods return the message data
//

pfUlong gsmpEventMessage :: getPort(void) const
{
    return _port;
}

pfUlong gsmpEventMessage :: getPortSessionNumber(void) const
{
    return _portSessionNumber;
}

pfUlong gsmpEventMessage :: getEventSequenceNumber(void) const
{
    return _eventSequenceNumber;
}

pfUlong gsmpEventMessage :: getVPI(void) const
{
    return _VPI;
}

pfUlong gsmpEventMessage :: getVCI(void) const
{
    return _VCI;
}

//
// Function: gsmpPortUpMessage
// 
// Description:
//     Default constructor
//

gsmpPortUpEventMessage :: gsmpPortUpEventMessage(void)
    :gsmpEventMessage()
{
    _messageType = gsmpEventMessage::PORT_UP;
    return;
}

//
// Function: gsmpPortUpMessage
// 
// Description:
//     Constructor
//

gsmpPortUpEventMessage :: gsmpPortUpEventMessage(pfUlong port_,
                                                 pfUlong portSessionNumber_,
                                                 pfUlong eventSequenceNumber_)
    :gsmpEventMessage()
{
    _messageType = gsmpEventMessage::PORT_UP;
    _port = port_;
    _portSessionNumber = portSessionNumber_;
    _eventSequenceNumber = eventSequenceNumber_;
    return;
}

//
// Function: gsmpPortUpMessage
// 
// Description:
//     Copy constructor
//

gsmpPortUpEventMessage :: gsmpPortUpEventMessage(
    const gsmpPortUpEventMessage &other_)
    :gsmpEventMessage(other_)
{
    return;
}

//
// Function: ~gsmpPortUpMessage
// 
// Description:
//     Destructor
//

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

//
// Function: clone
// 
// Description:
//

gsmpPortUpEventMessage *gsmpPortUpEventMessage :: clone(void)
{
    gsmpPortUpEventMessage *message = new gsmpPortUpEventMessage(*this);
    return message;
}

//
// Function: apply
// 
// Description:
//

void gsmpPortUpEventMessage :: apply(pfState *state_, pfProtocol *protocol_)
{
    gsmpState *state = dynamic_cast<gsmpState*>(state_);
    THROW_IF_DYNAMIC_CAST_FAILED(state);
    state->gsmpPortUpEventMessageAct(this, protocol_); 
    return;
}

//
// Function: gsmpPortDownMessage
// 
// Description:
//     Default constructor
//

gsmpPortDownEventMessage :: gsmpPortDownEventMessage(void)
    :gsmpEventMessage()
{
    _messageType = gsmpEventMessage::PORT_DOWN;
    return;
}

//
// Function: gsmpPortDownMessage
// 
// Description:
//     Constructor
//

gsmpPortDownEventMessage :: gsmpPortDownEventMessage(
    pfUlong port_,
    pfUlong portSessionNumber_,
    pfUlong eventSequenceNumber_)
    :gsmpEventMessage()
{
    _messageType = gsmpEventMessage::PORT_DOWN;
    _port = port_;
    _portSessionNumber = portSessionNumber_;
    _eventSequenceNumber = eventSequenceNumber_;
    return;
}

//
// Function: gsmpPortDownMessage
// 
// Description:
//     Copy constructor
//

gsmpPortDownEventMessage :: gsmpPortDownEventMessage(
    const gsmpPortDownEventMessage &other_)
    :gsmpEventMessage(other_)
{
    return;
}

//
// Function: ~gsmpPortDownMessage
// 
// Description:
//     Destructor
//

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

//
// Function: clone
// 
// Description:
//

gsmpPortDownEventMessage *gsmpPortDownEventMessage :: clone(void)
{
    gsmpPortDownEventMessage *message = new gsmpPortDownEventMessage(*this);
    return message;
}

//
// Function: apply
// 
// Description:
//

void gsmpPortDownEventMessage :: apply(pfState *state_, pfProtocol *protocol_)
{
    gsmpState *state = dynamic_cast<gsmpState*>(state_);
    THROW_IF_DYNAMIC_CAST_FAILED(state);
    state->gsmpPortDownEventMessageAct(this, protocol_); 
    return;
}

//
// Function: gsmpInvalidVPIVCIEventMessage
// 
// Description:
//     Default constructor
//

gsmpInvalidVPIVCIEventMessage :: gsmpInvalidVPIVCIEventMessage(void)
    :gsmpEventMessage()
{
    _messageType = gsmpEventMessage::INVALID_VPIVCI;
    return;
}

//
// Function: gsmpInvalidVPIVCIEventMessage
// 
// Description:
//     Constructor
//

gsmpInvalidVPIVCIEventMessage :: gsmpInvalidVPIVCIEventMessage(
    pfUlong port_,
    pfUlong portSessionNumber_,
    pfUlong eventSequenceNumber_,
    pfUlong VPI_,
    pfUlong VCI_ )
    :gsmpEventMessage()
{
    _messageType = gsmpEventMessage::INVALID_VPIVCI;
    _port = port_;
    _portSessionNumber = portSessionNumber_;
    _eventSequenceNumber = eventSequenceNumber_;    
    _VPI = VPI_;
    _VCI = VCI_;
    return;
}

//
// Function: gsmpInvalidVPIVCIEventMessage
// 
// Description:
//     Copy constructor
//

gsmpInvalidVPIVCIEventMessage :: gsmpInvalidVPIVCIEventMessage(
    const gsmpInvalidVPIVCIEventMessage &other_)
    :gsmpEventMessage(other_)
{
    return;
}

//
// Function: ~gsmpInvalidVPIVCIEventMessage
// 
// Description:
//     Destructor
//

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

//
// Function: clone
// 
// Description:
//

gsmpInvalidVPIVCIEventMessage *gsmpInvalidVPIVCIEventMessage :: clone(void)
{
    gsmpInvalidVPIVCIEventMessage *message =
        new gsmpInvalidVPIVCIEventMessage(*this);
    return message;
}

//
// Function: apply
// 
// Description:
//

void gsmpInvalidVPIVCIEventMessage :: apply(pfState *state_,
                                            pfProtocol *protocol_)
{
    gsmpState *state = dynamic_cast<gsmpState*>(state_);
    THROW_IF_DYNAMIC_CAST_FAILED(state);
    state->gsmpInvalidVPIVCIEventMessageAct(this, protocol_); 
    return;
}

//
// Function: gsmpNewPortEventMessage
// 
// Description:
//     Default constructor
//

gsmpNewPortEventMessage :: gsmpNewPortEventMessage(void)
    :gsmpEventMessage()
{
    _messageType = gsmpEventMessage::NEW_PORT;
    return;
}

//
// Function: gsmpNewPortEventMessage
// 
// Description:
//     Constructor
//

gsmpNewPortEventMessage :: gsmpNewPortEventMessage(
    pfUlong port_,
    pfUlong portSessionNumber_,
    pfUlong eventSequenceNumber_)
    :gsmpEventMessage()
{
    _messageType = gsmpEventMessage::NEW_PORT;
    _port = port_;
    _portSessionNumber = portSessionNumber_;
    _eventSequenceNumber = eventSequenceNumber_;
    return;
}

//
// Function: gsmpNewPortEventMessage
// 
// Description:
//     Copy constructor
//

gsmpNewPortEventMessage :: gsmpNewPortEventMessage(
    const gsmpNewPortEventMessage &other_)
    :gsmpEventMessage(other_)
{
    return;
}

//
// Function: ~gsmpNewPortEventMessage
// 
// Description:
//     Destructor
//

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

//
// Function: clone
// 
// Description:
//

gsmpNewPortEventMessage *gsmpNewPortEventMessage :: clone(void)
{
    gsmpNewPortEventMessage *message = new gsmpNewPortEventMessage(*this);
    return message;
}

//
// Function: apply
// 
// Description:
//

void gsmpNewPortEventMessage :: apply(pfState *state_, pfProtocol *protocol_)
{
    gsmpState *state = dynamic_cast<gsmpState*>(state_);
    THROW_IF_DYNAMIC_CAST_FAILED(state);
    state->gsmpNewPortEventMessageAct(this, protocol_); 
    return;
}

//
// Function: gsmpDeadPortEventMessage
// 
// Description:
//     Default constructor
//

gsmpDeadPortEventMessage :: gsmpDeadPortEventMessage(void)
    :gsmpEventMessage()
{
    _messageType = gsmpEventMessage::DEAD_PORT;
    return;
}

//
// Function: gsmpDeadPortEventMessage
// 
// Description:
//     Constructor
//

gsmpDeadPortEventMessage :: gsmpDeadPortEventMessage(
    pfUlong port_,
    pfUlong portSessionNumber_,
    pfUlong eventSequenceNumber_)
    :gsmpEventMessage()
{
    _messageType = gsmpEventMessage::DEAD_PORT;
    _port = port_;
    _portSessionNumber = portSessionNumber_;
    _eventSequenceNumber = eventSequenceNumber_;
    return;
};

//
// Function: gsmpDeadPortEventMessage
// 
// Description:
//     Copy constructor
//

gsmpDeadPortEventMessage :: gsmpDeadPortEventMessage(
    const gsmpDeadPortEventMessage &other_)
    :gsmpEventMessage(other_)
{
    return;
}

//
// Function: ~gsmpDeadPortEventMessage
// 
// Description:
//     Destructor
//

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

//
// Function: clone
// 
// Description:
//

gsmpDeadPortEventMessage *gsmpDeadPortEventMessage :: clone(void)
{
    gsmpDeadPortEventMessage *message = new gsmpDeadPortEventMessage(*this);
    return message;
}

//
// Function: apply
// 
// Description:
//

void gsmpDeadPortEventMessage :: apply(pfState *state_, pfProtocol *protocol_)
{
    gsmpState *state = dynamic_cast<gsmpState*>(state_);
    THROW_IF_DYNAMIC_CAST_FAILED(state);
    state->gsmpDeadPortEventMessageAct(this, protocol_); 
    return;
}

//
// Function: gsmpListenEventsMessage
//
// Description:  
//     Default constructor
//

gsmpListenEventsMessage :: gsmpListenEventsMessage(void)
    : gsmpEventMessage()
{
    return;
}

//
// Function: gsmpListenEventsMessage
//
// Description:  
//     Copy constructor
//

gsmpListenEventsMessage :: gsmpListenEventsMessage(
    const gsmpListenEventsMessage &other_)
    : gsmpEventMessage(other_)
{
    return;
}

//
// Function: ~gsmpListenEventsMessage
//
// Description:  
//     Destructor
//

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

//
// Function: clone
// 
// Description:
//

gsmpListenEventsMessage *gsmpListenEventsMessage :: clone(void)
{
    gsmpListenEventsMessage *message = new gsmpListenEventsMessage(*this);
    return message;
}

//
// Function: apply
//
// Description:  
//

void gsmpListenEventsMessage :: apply(pfState *state_, pfProtocol *protocol_)
{
    gsmpProtocolState *state = dynamic_cast<gsmpProtocolState *>(state_);
    THROW_IF_DYNAMIC_CAST_FAILED(state);
    state->gsmpListenEventsMessageAct(this, protocol_);
    return;
}

//
// Function: gsmpForgetEventsMessage
//
// Description:  
//     Default constructor
//

gsmpForgetEventsMessage :: gsmpForgetEventsMessage(void)
    : gsmpEventMessage()
{
    return;
}

//
// Function: gsmpForgetEventsMessage
//
// Description:  
//     Copy constructor
//

gsmpForgetEventsMessage :: gsmpForgetEventsMessage(
    const gsmpForgetEventsMessage &other_)
    : gsmpEventMessage(other_)
{
    return;
}

//
// Function: ~gsmpForgetEventsMessage
//
// Description:  
//     Destructor
//

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

//
// Function: clone
// 
// Description:
//

gsmpForgetEventsMessage *gsmpForgetEventsMessage :: clone(void)
{
    gsmpForgetEventsMessage *message = new gsmpForgetEventsMessage(*this);
    return message;
}

//
// Function: apply
//
// Description:  
//

void gsmpForgetEventsMessage :: apply(pfState *state_, pfProtocol *protocol_)
{
    gsmpProtocolState *state = dynamic_cast<gsmpProtocolState *>(state_);
    THROW_IF_DYNAMIC_CAST_FAILED(state);
    state->gsmpForgetEventsMessageAct(this, protocol_);
    return;
}