//Editor-Info: -*- C++ -*-
//
//Subject: GSMP
//
//File: gsmpeventmessages.h
//
//Version: $Revision: 1.6 $
//
//State: $State: Exp $
//
//Date: $Date: 1998/12/10 10:26:59 $
//
//Organisation:
//      Helsinki University of Technology
//      Laboratory of Telecommunications Software and Multimedia
//
//Author:
//      Harri Sunila
//
//Description:
//      Classes for GSMP Event Messages
//
//Copyright:
//      Copyright 1999 Helsinki University of Technology
//      ALL RIGHTS RESERVED BETWEEN JANUARY 1996 AND JUNE 1999.
//      
//Licence:
//     
//
//History:
//

#ifndef __GSMP_GSMPEVENTMESSAGE_H__
#define __GSMP_GSMPEVENTMESSAGE_H__


#include "gsmpmessage.h"
#include "gsmpdefs.h"
#include "gsmpstate.h"

//
// Class: gsmpEventMessage
// 
// Description:
//

class gsmpEventMessage : public gsmpMessage
{
    public:
        // Definitions for different kind of messages

        static const pfByte PORT_UP = 80;
        static const pfByte PORT_DOWN = 81;
        static const pfByte INVALID_VPIVCI = 82;
        static const pfByte NEW_PORT = 83;
        static const pfByte DEAD_PORT = 84;
        
        gsmpEventMessage(const gsmpEventMessage &other_);
        virtual ~gsmpEventMessage(void);
        
        virtual pfFrame encodeFrame(void);
        virtual void decodeFrame(pfFrame &frame_);

        pfUlong getPort(void) const;
        pfUlong getPortSessionNumber(void) const;
        pfUlong getEventSequenceNumber(void) const;
        pfUlong getVPI(void) const;
        pfUlong getVCI(void) const;
        
    protected:
        gsmpEventMessage(void);

        pfUlong _port;
        pfUlong _portSessionNumber;
        pfUlong _eventSequenceNumber;
        pfUlong _VPI;
        pfUlong _VCI;
};

//
// Class: gsmpPortUpEventMessage
// 
// Description:
//

class gsmpPortUpEventMessage : public gsmpEventMessage
{
    public:
        gsmpPortUpEventMessage(void);
        gsmpPortUpEventMessage(pfUlong port_,
                               pfUlong portSessionNumber_,
                               pfUlong eventSequenceNumber_);
        gsmpPortUpEventMessage(const gsmpPortUpEventMessage &other_);
        virtual ~gsmpPortUpEventMessage(void);

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

//
// Class: gsmpPortDownEventMessage
// 
// Description:
//

class gsmpPortDownEventMessage : public gsmpEventMessage
{
    public:
        gsmpPortDownEventMessage(void);
        gsmpPortDownEventMessage(pfUlong port_,
                                 pfUlong portSessionNumber_,
                                 pfUlong eventSequenceNumber_);
        gsmpPortDownEventMessage(const gsmpPortDownEventMessage &other_);
        virtual ~gsmpPortDownEventMessage(void);

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

//
// Class: gsmpInvalidVPIVCIEventMessage
// 
// Description:
//

class gsmpInvalidVPIVCIEventMessage : public gsmpEventMessage
{
    public:
        gsmpInvalidVPIVCIEventMessage(void);
        gsmpInvalidVPIVCIEventMessage(pfUlong port_,
                                      pfUlong portSessionNumber_,
                                      pfUlong eventSequenceNumber_,
                                      pfUlong VPI_,
                                      pfUlong VCI_);
        gsmpInvalidVPIVCIEventMessage(
            const gsmpInvalidVPIVCIEventMessage &other_);
        virtual ~gsmpInvalidVPIVCIEventMessage(void);

        virtual gsmpInvalidVPIVCIEventMessage *clone(void);
        void apply(pfState *state_, pfProtocol *protocol_);
};
        
//
// Class: gsmpNewPortEventMessage
// 
// Description:
//

class gsmpNewPortEventMessage : public gsmpEventMessage
{
    public:
        gsmpNewPortEventMessage(void);
        gsmpNewPortEventMessage(pfUlong port_,
                                pfUlong portSessionNumber_,
                                pfUlong eventSequenceNumber_);
        gsmpNewPortEventMessage(const gsmpNewPortEventMessage &other_);
        virtual ~gsmpNewPortEventMessage(void);

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

//
// Class: gsmpDeadPortEventMessage
// 
// Description:
//

class gsmpDeadPortEventMessage : public gsmpEventMessage
{
    public:
        gsmpDeadPortEventMessage(void);
        gsmpDeadPortEventMessage(pfUlong port_,
                                 pfUlong portSessionNumber_,
                                 pfUlong eventSequenceNumber_ );
        gsmpDeadPortEventMessage(const gsmpDeadPortEventMessage &other_);
        virtual ~gsmpDeadPortEventMessage(void);
        
        virtual gsmpDeadPortEventMessage *clone(void);
        void apply(pfState *state_, pfProtocol *protocol_);
};

//
// Class: gsmpListenEventsMessage
//
// Description: 
//     This is an implementation specific message to tell the GSMP protocol
//     conduit that the sender is interested in event messages. Whenever the
//     GSMP protocol conduit receives a gsmpListenEventsMessage, it adds the
//     sender in a specific map of conduits, to whom it forwards every event
//     message it receives from the switch.
//

class gsmpListenEventsMessage : public gsmpEventMessage
{
    public:
        gsmpListenEventsMessage(void);
        gsmpListenEventsMessage(const gsmpListenEventsMessage &other_);
        virtual ~gsmpListenEventsMessage(void);

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

//
// Class: gsmpForgetEventsMessage
//
// Description: 
//     This is an implementation specific message to tell the GSMP protocol
//     conduit that the sender is not anymore interested in event messages.
//     Whenever the GSMP protocol conduit receives a gsmpForgetEventsMessage,
//     it removes the sender from a specific map of conduits, to whom it
//     forwards every event message it receives from the switch.
//

class gsmpForgetEventsMessage : public gsmpEventMessage
{
    public:
        gsmpForgetEventsMessage(void);
        gsmpForgetEventsMessage(const gsmpForgetEventsMessage &other_);
        virtual ~gsmpForgetEventsMessage(void);

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

#endif // __GSMP_GSMPEVENTMESSAGE_H__