//Editor-Info: -*- C++ -*-
//
//Subject: GSMP
//
//File: gsmpconfigurationmessage.cpp
//
//Version: $Revision: 1.8 $
//
//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 "gsmpconfigurationmessages.h"
#include "gsmpexceptions.h"
#include "pf/error.h"

//
//Function: gsmpConfigurationRequestMessage 
//
//Description:
//    Constructor 
//

gsmpConfigurationRequestMessage :: gsmpConfigurationRequestMessage(void)
    : gsmpMessage(),
      _port(0)
    
{
    _result = GSMP_ACK_ALL;
    return;
}

//
// Function: gsmpConfigurationRequestMessage
//
// Description: 
//     Copy constructor 
//

gsmpConfigurationRequestMessage :: gsmpConfigurationRequestMessage(
    const gsmpConfigurationRequestMessage &other_)
    : gsmpMessage(other_),
      _port(other_._port)
{
    return;
}

//
// Function: ~gsmpConfigurationRequestMessage
//
// Description:  
//     Destructor
//

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

//
// Function: encodeFrame 
//
// Description:  
//

pfFrame gsmpConfigurationRequestMessage :: encodeFrame(void)
{
    _frame.clear();
    _frame.putLast(_version);
    _frame.putLast(_messageType);
    _frame.putLast(_result);
    _frame.putLast(_code);
    _frame.putLast32bit(_transactionIdentifier);
    _frame.putLast32bit(_port);
    return _frame;
}    

//
// Function: decodeFrame 
//
// Description:  
//

void gsmpConfigurationRequestMessage :: decodeFrame(pfFrame &frame_)
{
    _frame = frame_;
    _version = frame_.getFirst();
    _messageType = frame_.getFirst();
    _result = frame_.getFirst();
    _code = frame_.getFirst();
    _transactionIdentifier = frame_.getFirst32bit();
    _port = frame_.getFirst32bit();
    if (frame_.length() != 0)
    {
        throw gsmpInvalidLengthException(PF_EX_INFO);
    }
    return;
}

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

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

//
// Function: getPort 
//
// Description:  
//

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

//
//Function: gsmpSwitchConfigurationRequestMessage 
//
//Description:
//    Default constructor
//

gsmpSwitchConfigurationRequestMessage ::
gsmpSwitchConfigurationRequestMessage(void)
    : gsmpConfigurationRequestMessage()
{
    _messageType = gsmpMessage::SWITCH_CONFIGURATION;
    return;
}

//
// Function: gsmpSwitchConfigurationRequestMessage
//
// Description:  
//     Constructor
//

gsmpSwitchConfigurationRequestMessage
:: gsmpSwitchConfigurationRequestMessage(pfUlong transactionIdentifier_)
    : gsmpConfigurationRequestMessage()
{
    _transactionIdentifier = transactionIdentifier_;
    _messageType = gsmpMessage::SWITCH_CONFIGURATION;
    return;
}

//
// Function: gsmpSwitchConfigurationRequestMessage
//
// Description:  
//     Copy constructor
//

gsmpSwitchConfigurationRequestMessage
:: gsmpSwitchConfigurationRequestMessage(
    const gsmpSwitchConfigurationRequestMessage &other_)
    : gsmpConfigurationRequestMessage(other_)
{
    return;
}

//
// Function: ~gsmpSwitchConfigurationReqestMessage 
//
// Description:
//     Destructor
//

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

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

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

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

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

//
//Function: gsmpPortConfigurationRequestMessage 
//
//Description:
//    Default constructor
//

gsmpPortConfigurationRequestMessage ::
gsmpPortConfigurationRequestMessage(void)
    : gsmpConfigurationRequestMessage()
{
    _messageType = gsmpMessage::PORT_CONFIGURATION;
    return;
}

//
// Function: gsmpPortConfigurationRequestMessage 
//
// Description:  
//     Constructor
//
    
gsmpPortConfigurationRequestMessage
:: gsmpPortConfigurationRequestMessage(pfUlong transactionIdentifier_,
                                       pfUlong port_)
    : gsmpConfigurationRequestMessage()
{
    _messageType = gsmpMessage::PORT_CONFIGURATION;
    _transactionIdentifier = transactionIdentifier_;
    _port = port_;
    return;
}

//
// Function: gsmpPortConfigurationRequestMessage
//
// Description:  
//     Copy constructor
//

gsmpPortConfigurationRequestMessage
:: gsmpPortConfigurationRequestMessage(
       const gsmpPortConfigurationRequestMessage &other_)
    : gsmpConfigurationRequestMessage(other_)
{
    return;
}

//
// Function: ~gsmpPortConfigurationRequestMessage 
//
// Description:  
//     Destructor

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

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

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

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

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

//
//Function: gsmpAllPortsConfigurationRequestMessage 
//
//Description:
//    Default constructor
//

gsmpAllPortsConfigurationRequestMessage ::
gsmpAllPortsConfigurationRequestMessage(void)
    : gsmpConfigurationRequestMessage()
{
    _messageType = gsmpMessage::ALL_PORTS_CONFIGURATION;
    return;
}

//
// Function: gsmpAllPortsConfigurationRequestMessage 
//
// Description:  
//     Constructor
//

gsmpAllPortsConfigurationRequestMessage
:: gsmpAllPortsConfigurationRequestMessage(pfUlong transactionIdentifier_)
    : gsmpConfigurationRequestMessage()
{
    _transactionIdentifier = transactionIdentifier_;
    _messageType = gsmpMessage::ALL_PORTS_CONFIGURATION;
    return;
}

//
// Function: gsmpAllPortsConfigurationRequestMessage
//
// Description:  
//     Copy constructor
//

gsmpAllPortsConfigurationRequestMessage
:: gsmpAllPortsConfigurationRequestMessage(
       const gsmpAllPortsConfigurationRequestMessage &other_)
    : gsmpConfigurationRequestMessage(other_)
{
    return;
}

//
// Function: ~gsmpAllPortsConfigurationRequestMessage
//
// Description:
//     Destructor
//

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

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

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

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

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

//
//Function: gsmpSwitchConfigurationResponseMessage
//
//Description:
//    Default constructor
//

gsmpSwitchConfigurationResponseMessage ::
gsmpSwitchConfigurationResponseMessage(void)
    : gsmpMessage(),
      _firmwareVersionNumber(0),
      _switchType(0),
      _switchName()
{
    _messageType = gsmpMessage::SWITCH_CONFIGURATION;
    return;
}

//
// Function: gsmpSwitchConfigurationResponseMessage 
//
// Description:
//     Constructor
//

gsmpSwitchConfigurationResponseMessage ::
gsmpSwitchConfigurationResponseMessage(pfUlong transactionIdentifier_,
                                       pfUlong firmwareVersionNumber_,
                                       pfUlong switchType_,
                                       const string &switchName_)
    : gsmpMessage()
{
    _messageType = gsmpMessage::SWITCH_CONFIGURATION;
    _transactionIdentifier = transactionIdentifier_;
    _firmwareVersionNumber = firmwareVersionNumber_;
    _switchType = switchType_;
    _switchName = switchName_;
    return;
}
//
// Function: gsmpSwitchConfigurationResponseMessage 
//
// Description:
//     Copy constructor
//

gsmpSwitchConfigurationResponseMessage ::
gsmpSwitchConfigurationResponseMessage(
    const gsmpSwitchConfigurationResponseMessage &other_)
    : gsmpMessage(other_),
      _firmwareVersionNumber(other_._firmwareVersionNumber),
      _switchType(other_._switchType),
      _switchName(other_._switchName)
{
    return;
}

//
// Function: ~gsmpSwitchConfigurationResponseMessage 
//
// Description:  
//     Destructor
//

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

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

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

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

pfUlong gsmpSwitchConfigurationResponseMessage ::
getFirmwareVersionNumber(void) const
{
    return _firmwareVersionNumber;
}

pfUlong gsmpSwitchConfigurationResponseMessage :: getSwitchType(void) const
{
    return _switchType;
}

string gsmpSwitchConfigurationResponseMessage :: getSwitchName(void) const
{
    return _switchName;
}


//
// Function: decodeFrame 
//
// Description:  
//

void gsmpSwitchConfigurationResponseMessage :: decodeFrame(pfFrame &frame_)
{
    _frame = frame_;
    _version = frame_.getFirst();
    _messageType = frame_.getFirst();
    _result = frame_.getFirst();
    _code = frame_.getFirst();
    _transactionIdentifier = frame_.getFirst32bit();
    _firmwareVersionNumber = frame_.getFirst16bit();
    frame_.getFirst16bit(); // for reserved
    _switchType = frame_.getFirst16bit();

    // Decode the switch name as hex string.
    frame_.useHex();
    _switchName = frame_.toString();
    
    // Check that the frame is correct
    if (_switchName.length() != (2 * gsmpMessage::GSMP_SWITCH_NAME_LENGTH))
    {
        _switchName = "000000000000";
        throw gsmpInvalidLengthException(PF_EX_INFO);
    }
    return;
}

//
// Function: encodeFrame
//
// Description:  
//

pfFrame gsmpSwitchConfigurationResponseMessage :: encodeFrame(void)
{
    _frame.clear();
    _frame.putLast(_version);
    _frame.putLast(_messageType);
    _frame.putLast(_result);
    _frame.putLast(_code);
    _frame.putLast32bit(_transactionIdentifier);
    _frame.putLast16bit(_firmwareVersionNumber);
    _frame.putLast16bit(0);
    _frame.putLast16bit(_switchType);

    _frame.useHex();
    if (_switchName.length() != (2 * gsmpMessage::GSMP_SWITCH_NAME_LENGTH))
    {
        _switchName = "000000000000";
        throw gsmpInvalidLengthException(PF_EX_INFO);
    }
    _frame.fromString(_switchName);
    return _frame;
}

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

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

//
//Function: gsmpPortConfigurationResponseMessage
//
//Description:
//    Default constructor
//

gsmpPortConfigurationResponseMessage ::
gsmpPortConfigurationResponseMessage(void)
    : gsmpMessage(),
      _port(0),
      _portSessionNumber(0),
      _minVPI(0),
      _maxVPI(0),
      _minVCI(0),
      _maxVCI(0),
      _cellRate(0),
      _portStatus(0),
      _portType(0),
      _lineStatus(0),
      _priorities(0)
{
    _messageType = gsmpMessage::PORT_CONFIGURATION;
    return;
}

//
// Function: gsmpPortConfigurationResponseMessage
//
// Description:
//     Constructor
//
    
gsmpPortConfigurationResponseMessage
:: gsmpPortConfigurationResponseMessage(pfUlong transactionIdentifier_,
                                        pfUlong port_,
                                        pfUlong portSessionNumber_,
                                        pfUlong minVPI_,
                                        pfUlong maxVPI_,
                                        pfUlong minVCI_,
                                        pfUlong maxVCI_,
                                        pfUlong cellRate_,
                                        pfByte portStatus_,
                                        pfByte portType_,
                                        pfByte lineStatus_,
                                        pfByte priorities_)
    : gsmpMessage(),
      _port(port_),
      _portSessionNumber(portSessionNumber_),
      _minVPI(minVPI_),
      _maxVPI(maxVPI_),
      _minVCI(minVCI_),
      _maxVCI(maxVCI_),
      _cellRate(cellRate_),
      _portStatus(portStatus_),
      _portType(portType_),
      _lineStatus(lineStatus_),
      _priorities(priorities_)
{
    _messageType = gsmpMessage::PORT_CONFIGURATION;
    _transactionIdentifier = transactionIdentifier_;
    return;
}

//
// Function: gsmpPortConfigurationResponseMessage
//
// Description:
//     Copy constructor
//
    
gsmpPortConfigurationResponseMessage :: gsmpPortConfigurationResponseMessage(
    const gsmpPortConfigurationResponseMessage &other_)
    : gsmpMessage(other_),
      _port(other_._port),
      _portSessionNumber(other_._portSessionNumber),
      _minVPI(other_._minVPI),
      _maxVPI(other_._maxVPI),
      _minVCI(other_._minVCI),
      _maxVCI(other_._maxVCI),
      _cellRate(other_._cellRate),
      _portStatus(other_._portStatus),
      _portType(other_._portType),
      _lineStatus(other_._lineStatus),
      _priorities(other_._priorities)
{
    return;
}

//
// Function: ~gsmpPortConfigurationResponseMessage
//
// Description:
//     Destructor
//

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

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

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

//
// Function: decodeFrame
//
// Description:  
//

void gsmpPortConfigurationResponseMessage :: 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();
    _minVPI = frame_.getFirst16bit();
    _maxVPI = frame_.getFirst16bit();
    _minVCI = frame_.getFirst16bit();
    _maxVCI = frame_.getFirst16bit();
    _cellRate = frame_.getFirst32bit();
    _portStatus = frame_.getFirst();
    _portType = frame_.getFirst();
    _lineStatus = frame_.getFirst();
    _priorities = frame_.getFirst();
    if (frame_.length() != 0)
    {
        throw gsmpInvalidLengthException(PF_EX_INFO);
    }
    return;
}

//
// Function: encodeFrame 
//
// Description:  
//

pfFrame gsmpPortConfigurationResponseMessage :: 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.putLast16bit((_minVPI & gsmpMessage::GSMP_VPI_MASK));
    _frame.putLast16bit((_maxVPI & gsmpMessage::GSMP_VPI_MASK));
    _frame.putLast16bit(_minVCI);
    _frame.putLast16bit(_maxVCI);
    _frame.putLast32bit(_cellRate);
    _frame.putLast(_portStatus);
    _frame.putLast(_portType);
    _frame.putLast(_lineStatus);
    _frame.putLast(_priorities);
    return _frame;
}    

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

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

//
//Function: Get
//
//Description:
//    These methods return the data
//

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

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

pfUlong gsmpPortConfigurationResponseMessage :: getMinVPI(void) const
{
    return _minVPI;
}

pfUlong gsmpPortConfigurationResponseMessage :: getMaxVPI(void) const
{
    return _maxVPI;
}

pfUlong gsmpPortConfigurationResponseMessage :: getMinVCI(void) const
{
    return _minVCI;
}

pfUlong gsmpPortConfigurationResponseMessage :: getMaxVCI(void) const
{
    return _maxVCI;
}

pfUlong gsmpPortConfigurationResponseMessage :: getCellRate(void) const
{
    return _cellRate;
}

pfByte gsmpPortConfigurationResponseMessage :: getPortStatus(void) const
{
    return _portStatus;
}

pfByte gsmpPortConfigurationResponseMessage :: getPortType(void) const
{
    return _portType;
}

pfByte gsmpPortConfigurationResponseMessage :: getLineStatus(void) const
{
    return _lineStatus;
}

pfByte gsmpPortConfigurationResponseMessage :: getPriorities(void) const
{
    return _priorities;
}

//
//Function: gsmpPortRecord
//
//Description:
//    Default constructor
//

gsmpPortRecord :: gsmpPortRecord(void)
    : _port(0),
      _portSessionNumber(0),
      _minVPI(0),
      _maxVPI(0),
      _minVCI(0),
      _maxVCI(0),
      _cellRate(0),
      _portStatus(0),
      _portType(0),
      _lineStatus(0),
      _priorities(0)
{
    return;
}

//
//Function: gsmpPortRecord
//
//Description:
//    Constructor
//

gsmpPortRecord :: gsmpPortRecord(pfUlong port_,
                                 pfUlong portSessionNumber_,
                                 pfUlong minVPI_,
                                 pfUlong maxVPI_,
                                 pfUlong minVCI_,
                                 pfUlong maxVCI_,
                                 pfUlong cellRate_,
                                 pfUlong portStatus_,
                                 pfUlong portType_,
                                 pfUlong lineStatus_,
                                 pfUlong priorities_)
    : _port(port_),
      _portSessionNumber(portSessionNumber_),
      _minVPI(minVPI_),
      _maxVPI(maxVPI_),
      _minVCI(minVCI_),
      _maxVCI(maxVCI_),
      _cellRate(cellRate_),
      _portStatus(portStatus_),
      _portType(portType_),
      _lineStatus(lineStatus_),
      _priorities(priorities_)
{
    return;
}

//
//Function: gsmpPortRecord
//
//Description:
//    Copy constructor
//

gsmpPortRecord :: gsmpPortRecord(const gsmpPortRecord &other_)
    : _port(other_._port),
      _portSessionNumber(other_._portSessionNumber),
      _minVPI(other_._minVPI),
      _maxVPI(other_._maxVPI),
      _minVCI(other_._minVCI),
      _maxVCI(other_._maxVCI),
      _cellRate(other_._cellRate),
      _portStatus(other_._portStatus),
      _portType(other_._portType),
      _lineStatus(other_._lineStatus),
      _priorities(other_._priorities)
{
    return;
}

//
// Function: ~gsmpPortRecord
//
// Description:
//     Destructor
//

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

//
// Function: operator=
//
// Description:  
//
gsmpPortRecord &gsmpPortRecord :: operator=(const gsmpPortRecord &other_)
{
    if (this != &other_)
    {
        _port = other_._port;
        _portSessionNumber = other_._portSessionNumber;
        _minVPI = other_._minVPI;
        _maxVPI = other_._maxVPI;
        _minVCI = other_._minVCI;
        _maxVCI = other_._maxVCI;
        _cellRate = other_._cellRate;
        _portStatus = other_._portStatus;
        _portType = other_._portType;
        _lineStatus = other_._lineStatus;
        _priorities = other_._priorities;
    }
    return *this;
}

//
//Function: Get
//
//Description:
//    These methods return the data
//

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

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

pfUlong gsmpPortRecord :: getMinVPI(void) const
{
    return _minVPI;
}

pfUlong gsmpPortRecord :: getMaxVPI(void) const
{
    return _maxVPI;
}

pfUlong gsmpPortRecord :: getMinVCI(void) const
{
    return _minVCI;
}

pfUlong gsmpPortRecord :: getMaxVCI(void) const
{
    return _maxVCI;
}

pfUlong gsmpPortRecord :: getCellRate(void) const
{
    return _cellRate;
}

pfByte gsmpPortRecord :: getPortStatus(void) const
{
    return _portStatus;
}

pfByte gsmpPortRecord :: getPortType(void) const
{
    return _portType;
}

pfByte gsmpPortRecord :: getLineStatus(void) const
{
    return _lineStatus;
}

pfByte gsmpPortRecord :: getPriorities(void) const
{
    return _priorities;
}

//
//Function: gsmpAllPortsConfigurationMessage
//
//Description:
//    Default constructor
//

gsmpAllPortsConfigurationResponseMessage ::
gsmpAllPortsConfigurationResponseMessage(void)
    : gsmpMessage(),
      _numberOfRecords(0),
      _portRecordLength(gsmpMessage::PORT_RECORD_LENGTH),
      _portRecords()
{
    _messageType = gsmpMessage::ALL_PORTS_CONFIGURATION;
    return;
}

//
// Function: gsmpAllPortsConfigurationResponseMessage 
//
// Description:
//     Constructor
//

gsmpAllPortsConfigurationResponseMessage
:: gsmpAllPortsConfigurationResponseMessage(pfByte result_,
                                            pfByte code_,
                                            pfUlong transactionIdentifier_)
    : gsmpMessage(),
      _numberOfRecords(0),
      _portRecordLength(gsmpMessage::PORT_RECORD_LENGTH),
      _portRecords()
{
    _messageType = gsmpMessage::ALL_PORTS_CONFIGURATION;
    _result = result_;
    _code = code_;
    _transactionIdentifier = transactionIdentifier_;
    _portRecords.reserve(gsmpMessage::MAXIMUM_PORT_RECORD_NUMBER);
    return;
}

//
// Function: gsmpAllPortsConfigurationResponseMessage 
//
// Description:
//     Copy constructor
//

gsmpAllPortsConfigurationResponseMessage
:: gsmpAllPortsConfigurationResponseMessage(
    const gsmpAllPortsConfigurationResponseMessage &other_)
    : gsmpMessage(other_),
      _numberOfRecords(other_._numberOfRecords),
      _portRecordLength(other_._portRecordLength),
      _portRecords(other_._portRecords)
{
    return;
}

//
// Function: ~gsmpAllPortsConfigurationResponseMessage
//
// Description:
//     Destructor
//

gsmpAllPortsConfigurationResponseMessage ::
~gsmpAllPortsConfigurationResponseMessage(void)
{
    gsmpPortRecordIterator begin, end;
    begin = _portRecords.begin();
    end = _portRecords.end();
    _portRecords.erase(begin, end);
    return;
}

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

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

//
// Function: addPortRecord
//
// Description:
//     This method adds a new gsmpPortRecord in to _portRecord table in
//     GSMP All Ports Configuration Response Message
//

void gsmpAllPortsConfigurationResponseMessage :: addPortRecord(
    pfUlong port_,
    pfUlong portSessionNumber_,
    pfUlong minVPI_,
    pfUlong maxVPI_,
    pfUlong minVCI_,
    pfUlong maxVCI_,
    pfUlong cellRate_,
    pfByte portStatus_,
    pfByte portType_,
    pfByte lineStatus_,
    pfByte priorities_)
{
    if (_numberOfRecords == gsmpMessage::MAXIMUM_PORT_RECORD_NUMBER)
    {
        throw gsmpInvalidLengthException(PF_EX_INFO);
    }
    gsmpPortRecord record(port_,
                          portSessionNumber_,
                          minVPI_,
                          maxVPI_,
                          minVCI_,
                          maxVCI_,
                          cellRate_,
                          portStatus_,
                          portType_,
                          lineStatus_,
                          priorities_);
    _portRecords.push_back(record);
    _numberOfRecords++;
    return;
}

//
// Function: getPortRecords
//
// Description:
//     Returns the port record vector.
//

vector<gsmpPortRecord> gsmpAllPortsConfigurationResponseMessage
:: getPortRecords(void) const
{
    return _portRecords;
}

//
// Function: Get 
//
// Description:  
//     Return the message data

pfUlong gsmpAllPortsConfigurationResponseMessage ::
getNumberOfRecords(void) const
{
    return _numberOfRecords;
}

pfUlong gsmpAllPortsConfigurationResponseMessage
:: getPortRecordLength(void) const
{
    return _portRecordLength;
}

//
// Function: decodeFrame 
//
// Description:  
//

void gsmpAllPortsConfigurationResponseMessage :: decodeFrame(pfFrame &frame_)
{
    _frame = frame_;
    _version = frame_.getFirst();
    _messageType = frame_.getFirst();
    _result = frame_.getFirst();
    _code = frame_.getFirst();
    _transactionIdentifier = frame_.getFirst32bit();

    _numberOfRecords = frame_.getFirst16bit();
    if (_numberOfRecords > gsmpMessage::MAXIMUM_PORT_RECORD_NUMBER)
    {
        throw gsmpInvalidLengthException(PF_EX_INFO);
    }
    _portRecordLength = frame_.getFirst16bit();

    if (_portRecordLength != gsmpMessage::PORT_RECORD_LENGTH)
    {
        throw gsmpInvalidLengthException(PF_EX_INFO);
    }
    
    gsmpPortRecord *record;
    pfUlong i;
    pfUlong port, portSessionNumber;
    pfUlong minVPI, maxVPI, minVCI, maxVCI;
    pfUlong cellRate;
    pfByte portStatus, portType, lineStatus, priorities;
    for (i = 0; i < _numberOfRecords; i++)
    { 
        port = frame_.getFirst32bit();
        portSessionNumber = frame_.getFirst32bit();
        minVPI = frame_.getFirst16bit();
        maxVPI = frame_.getFirst16bit();
        minVCI = frame_.getFirst16bit();
        maxVCI = frame_.getFirst16bit();
        cellRate = frame_.getFirst32bit();
        portStatus = frame_.getFirst();
        portType = frame_.getFirst();
        lineStatus = frame_.getFirst();
        priorities = frame_.getFirst();
       
        record = new gsmpPortRecord(port,
                                    portSessionNumber,
                                    minVPI,
                                    maxVPI,
                                    minVCI,
                                    maxVCI,
                                    cellRate,
                                    portStatus,
                                    portType,
                                    lineStatus,
                                    priorities);
        _portRecords.push_back(*record);
    }
    if (frame_.length() != 0)
    {
        throw gsmpInvalidLengthException(PF_EX_INFO);
    }
    return;
}

//
// Function: encodeFrame
//
// Description:  
//

pfFrame gsmpAllPortsConfigurationResponseMessage :: encodeFrame(void)
{
    _frame.clear();
    _frame.putLast(_version);
    _frame.putLast(_messageType);
    _frame.putLast(_result);
    _frame.putLast(_code);
    _frame.putLast32bit(_transactionIdentifier);
    _frame.putLast16bit(_numberOfRecords);
    _frame.putLast16bit(_portRecordLength);

    pfUlong i;
    gsmpPortRecord portRecord;
    for(i = 0; i < _numberOfRecords; i++)
    {
        portRecord = _portRecords[i];
        _frame.putLast32bit(portRecord.getPort());
        _frame.putLast32bit(portRecord.getPortSessionNumber());
        _frame.putLast16bit(portRecord.getMinVPI());
        _frame.putLast16bit(portRecord.getMaxVPI());
        _frame.putLast16bit(portRecord.getMinVCI());
        _frame.putLast16bit(portRecord.getMaxVCI());
        _frame.putLast32bit(portRecord.getCellRate());
        _frame.putLast(portRecord.getPortStatus());
        _frame.putLast(portRecord.getPortType());
        _frame.putLast(portRecord.getLineStatus());
        _frame.putLast(portRecord.getPriorities());
    }
    return _frame;
}    

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

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