//Editor-Info: -*- C++ -*-
//
//Subject: TOVE project
//
//File: gsmpconnectionmanagementmessages.h
//
//State: $State: Exp $
//
//Version: $Revision: 1.5 $
//
//Date: $Date: 1998/06/18 05:21:56 $
//
//Organisation:
//      Helsinki University of Technology
//      Laboratory of Telecommunications Software and Multimedia
// 
//Author:
//      Harri Sunila
//
//Description:
//
//Copyright:    
//      Copyright 1999 Helsinki University of Technology
//      ALL RIGHTS RESERVED BETWEEN JANUARY 1996 AND JUNE 1999.
//      
//Licence:
//     
//
//History:
//
//

#ifndef __GSMP_GSMPCONNECTIONMANAGEMENTMESSAGES_H__
#define __GSMP_GSMPCONNECTIONMANAGEMENTMESSAGES_H__

#include "gsmpmessage.h"
#include "pf/bytes.h"

//
// Class: gsmpConnectionManagementMessage
//
// Description:
//	Connection management messages are used by the controller to establish,
//	delete, modify and verify connections across the switch.
//	

class gsmpConnectionManagementMessage : public gsmpMessage
{
    public:
        // Types for different kind of messages

        static const pfByte ADD_BRANCH = 16;
        static const pfByte DELETE_BRANCH = 17;
        static const pfByte DELETE_TREE = 18;
        static const pfByte VERIFY_TREE = 19;
        static const pfByte DELETE_ALL = 20;
        static const pfByte MOVE_BRANCH = 22;
        
        gsmpConnectionManagementMessage(
	    const gsmpConnectionManagementMessage &other_);
        virtual ~gsmpConnectionManagementMessage(void);

        virtual void decodeFrame(pfFrame &frame_);
        virtual pfFrame encodeFrame(void);

        pfUlong getPortSessionNumber(void) const;
        pfUlong getInputPort(void) const;
        pfUlong getInputVPI(void) const;
        pfUlong getInputVCI(void) const;
        pfUlong getOutputPort(void) const;
        pfUlong getOutputVPI(void) const;
        pfUlong getOutputVCI(void) const;
        pfUlong getNumberOfBranches(void) const;
        pfByte getPriority(void) const;
        
        void setPortSessionNumber(pfUlong portSessionNumber_);
        
    protected:
        gsmpConnectionManagementMessage(void);

        pfUlong _portSessionNumber;
        pfUlong _inputPort;
        pfUlong _inputVPI;
        pfUlong _inputVCI;
        pfUlong _outputPort;
        pfUlong _outputVPI;
        pfUlong _outputVCI;
        pfUlong _numberOfBranches;
        pfByte _priority;
};

//
// Class: gsmpAddBranchMessage
//
// Description:
//

class gsmpAddBranchMessage : public gsmpConnectionManagementMessage
{
    public:
        gsmpAddBranchMessage(void);
        gsmpAddBranchMessage(pfByte result_,
                             pfUlong transactionIdentifier_,
                             pfUlong portSessionNumber_,
                             pfUlong inputPort_,
                             pfUlong inputVPI_,
                             pfUlong inputVCI_,
                             pfUlong outputPort_,
                             pfUlong outputVPI_,
                             pfUlong outputVCI_,
                             pfByte priority_);
        gsmpAddBranchMessage(const gsmpAddBranchMessage &other_);
        virtual ~gsmpAddBranchMessage(void);

        virtual gsmpAddBranchMessage *clone(void);
        void apply(pfState *state_, pfProtocol *protocol_);
};

//
// Class: gsmpDeleteBranchMessage
//
// Description:
//

class gsmpDeleteBranchMessage : public gsmpConnectionManagementMessage
{
    public:
        gsmpDeleteBranchMessage(void);
        gsmpDeleteBranchMessage(pfByte result_,
                                pfUlong transactionIdentifier_,
                                pfUlong portSessionNumber_,
                                pfUlong inputPort_,
                                pfUlong inputVPI_,
                                pfUlong inputVCI_,
                                pfUlong outputPort_,
                                pfUlong outputVPI_,
                                pfUlong outputVCI_);
        gsmpDeleteBranchMessage(const gsmpDeleteBranchMessage &other_);
        virtual ~gsmpDeleteBranchMessage(void);

        virtual gsmpDeleteBranchMessage *clone(void);
        void apply(pfState *state_, pfProtocol *protocol_);
};

//
// Class: gsmpDeleteTreeMessage
//
// Description:
//

class gsmpDeleteTreeMessage : public gsmpConnectionManagementMessage
{
    public:
        gsmpDeleteTreeMessage(void);
        gsmpDeleteTreeMessage(pfByte result_,
                              pfUlong transactionIdentifier_,
                              pfUlong portSessionNumber_,
                              pfUlong inputPort_,
                              pfUlong inputVPI_,
                              pfUlong inputVCI_);
        gsmpDeleteTreeMessage(const gsmpDeleteTreeMessage &other_);
        virtual ~gsmpDeleteTreeMessage(void);

        virtual gsmpDeleteTreeMessage *clone(void);
        void apply(pfState *state_, pfProtocol *protocol_);
};

//
// Class: gsmpVerifyTreeMessage
//
// Description:
//

class gsmpVerifyTreeMessage : public gsmpConnectionManagementMessage
{
    public:
        gsmpVerifyTreeMessage(void);
        gsmpVerifyTreeMessage(pfByte result_,
                              pfUlong transactionIdentifier_,
                              pfUlong portSessionNumber_,
                              pfUlong inputPort_,
                              pfUlong inputVPI_,
                              pfUlong inputVCI_,
                              pfUlong numberOfBranches_);
        gsmpVerifyTreeMessage(const gsmpVerifyTreeMessage &other_);
        virtual ~gsmpVerifyTreeMessage(void);

        virtual gsmpVerifyTreeMessage *clone(void);
        void apply(pfState *state_, pfProtocol *protocol_);
};

//
// Class: gsmpDeleteAllMessage
//
// Description:
//

class gsmpDeleteAllMessage : public gsmpConnectionManagementMessage
{
    public:
        gsmpDeleteAllMessage(void);
        gsmpDeleteAllMessage(pfByte result_,
                             pfUlong transactionIdentifier_,
                             pfUlong portSessionNumber_,
                             pfUlong inputPort_);
        gsmpDeleteAllMessage(const gsmpDeleteAllMessage &other_);
        virtual ~gsmpDeleteAllMessage(void);

        virtual gsmpDeleteAllMessage *clone(void);
        void apply(pfState *state_, pfProtocol *protocol_);
};

//
// Class: gsmpMoveBranchMessage
//
// Description:
//

class gsmpMoveBranchMessage : public gsmpConnectionManagementMessage
{
    public:
        gsmpMoveBranchMessage(void);
        gsmpMoveBranchMessage(pfByte result_,
                              pfUlong transactionIdentifier_,
                              pfUlong portSessionNumber_,
                              pfUlong inputPort_,
                              pfUlong inputVPI_,
                              pfUlong inputVCI_,
                              pfUlong oldOutputPort_,
                              pfUlong oldOutputVPI_,
                              pfUlong oldOutputVCI_,
                              pfUlong newOutputPort_,
                              pfUlong newOutputVPI_,
                              pfUlong newOutputVCI_,
                              pfByte priority_);
        gsmpMoveBranchMessage(const gsmpMoveBranchMessage &other_);
        virtual ~gsmpMoveBranchMessage(void);

        virtual void decodeFrame(pfFrame &frame_);
        virtual pfFrame encodeFrame(void);

        virtual gsmpMoveBranchMessage *clone(void);
        void apply(pfState *state_, pfProtocol *protocol_);

        pfUlong getOldOutputPort(void) const;
        pfUlong getOldOutputVPI(void) const;
        pfUlong getOldOutputVCI(void) const;
        pfUlong getNewOutputPort(void) const;
        pfUlong getNewOutputVPI(void) const;
        pfUlong getNewOutputVCI(void) const;
        
    private:
        pfUlong _oldOutputPort;
        pfUlong _oldOutputVPI;
        pfUlong _oldOutputVCI;
        pfUlong _newOutputPort;
        pfUlong _newOutputVPI;
        pfUlong _newOutputVCI;
};

#endif  // __GSMP_GSMPCONNECTIONMANAGEMENTMESSAGES_H__