//Editor-Info: -*- C++ -*-
//
//Subject: TOVE project
//
//File: uniprimitives.h
//
//Version: $Revision: 1.13 $
//
//State: $State: Exp $
//
//Date: $Date: 1998/08/05 05:22:07 $
//
//Organisation:
//      Helsinki University of Technology
//      Laboratory of Telecommunications Software and Multimedia
//
//Author:
//      Jari Pusa
//
//Description:
//      Messengers used as UNI internal primitives between Co-ord,
//      Reset-Start-N (RSN), Reset-Respond-N (RRN), Point-to-Multipoint
//      (PMP) and UNI protocol objects. 
//
//Copyright:
//
//
//Licence:
//
//
//History: 

#ifndef __UNI_UNIPRIMITIVES_H__
#define __UNI_UNIPRIMITIVES_H__

#include "pf/messenge.h"

class pfState;
class pfProtocol;

//
// Description:
//      Interfaces and route for these messengers:
//      RSN/RRN->COORD->UNI
//

class uniRESET_ERRORind : public pfMessenger
{
    public:
        uniRESET_ERRORind(const uniRESET_ERRORind &other_);
        virtual ~uniRESET_ERRORind(void);
        virtual pfMessenger *clone(void);
        static uniRESET_ERRORind *create(pfUlong reason_, pfUlong callState_);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniRESET_ERRORind(void);
};

class uniRESETconf : public pfMessenger
{
    public:
        uniRESETconf(const uniRESETconf &other_);
        virtual ~uniRESETconf(void);
        virtual pfMessenger *clone(void);
        static uniRESETconf *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniRESETconf(void);
};

class uniRESETind : public pfMessenger
{
    public:
        uniRESETind(const uniRESETind &other_);
        virtual ~uniRESETind(void);
        virtual pfMessenger *clone(void);
        static uniRESETind *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniRESETind(void);
};

//
// Description:
//      Interfaces and route for these messengers:
//      UNI->COORD->RSN
//

class uniRESETreq : public pfMessenger
{
    public:
        uniRESETreq(const uniRESETreq &other_);
        virtual ~uniRESETreq(void);
        virtual pfMessenger *clone(void);
        static uniRESETreq *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniRESETreq(void);
};

//
// Description:
//      Interfaces and route for these messengers:
//      UNI->COORD->RRN
//

class uniRESETresp : public pfMessenger
{
    public:
        uniRESETresp(const uniRESETresp &other_);
        virtual ~uniRESETresp(void);
        virtual pfMessenger *clone(void);
        static uniRESETresp *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniRESETresp(void);
};

class uniRESET_ERRORresp : public pfMessenger
{
    public:
        uniRESET_ERRORresp(const uniRESET_ERRORresp &other_);
        virtual ~uniRESET_ERRORresp(void);
        virtual pfMessenger *clone(void);
        static uniRESET_ERRORresp *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniRESET_ERRORresp(void);
};

//
// Description:
//      Interface and route for these messengers:
//      UNI->COORD
//

class uniLINK_ESTABLISHreq : public pfMessenger
{
    public:
        uniLINK_ESTABLISHreq(const uniLINK_ESTABLISHreq &other_);
        virtual ~uniLINK_ESTABLISHreq(void);
        virtual pfMessenger *clone(void);
        static uniLINK_ESTABLISHreq *create(void); 
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniLINK_ESTABLISHreq(void);
};

class uniLINK_RELEASEreq : public pfMessenger
{
    public:
        uniLINK_RELEASEreq(const uniLINK_RELEASEreq &other_);
        virtual ~uniLINK_RELEASEreq(void);
        virtual pfMessenger *clone(void);
        static uniLINK_RELEASEreq *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniLINK_RELEASEreq(void);
};

//
// Description:
//      Interface and route for these messengers:
//      COORD->UNI
//

class uniLINK_ESTABLISHconf : public pfMessenger
{
    public:
        uniLINK_ESTABLISHconf(const uniLINK_ESTABLISHconf &other_);
        virtual ~uniLINK_ESTABLISHconf(void);
        virtual pfMessenger *clone(void);
        static uniLINK_ESTABLISHconf *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniLINK_ESTABLISHconf(void);
};

class uniLINK_ESTABLISHind : public pfMessenger
{
    public:
        uniLINK_ESTABLISHind(const uniLINK_ESTABLISHind &other_);
        virtual ~uniLINK_ESTABLISHind(void);
        virtual pfMessenger *clone(void);
        static uniLINK_ESTABLISHind *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniLINK_ESTABLISHind(void);
};

class uniLINK_ESTABLISHerror : public pfMessenger
{
    public:
        uniLINK_ESTABLISHerror(const uniLINK_ESTABLISHerror &other_);
        virtual ~uniLINK_ESTABLISHerror(void);
        virtual pfMessenger *clone(void);
        static uniLINK_ESTABLISHerror *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniLINK_ESTABLISHerror(void);
};

class uniLINK_RELEASEconf : public pfMessenger
{
    public:
        uniLINK_RELEASEconf(const uniLINK_RELEASEconf &other_);
        virtual ~uniLINK_RELEASEconf(void);
        virtual pfMessenger *clone(void);
        static uniLINK_RELEASEconf *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniLINK_RELEASEconf(void);
};

class uniLINK_RELEASEind : public pfMessenger
{
    public:
        uniLINK_RELEASEind(const uniLINK_RELEASEind &other_);
        virtual ~uniLINK_RELEASEind(void);
        virtual pfMessenger *clone(void);
        static uniLINK_RELEASEind *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniLINK_RELEASEind(void);
};

//
// Description:
//      Interface for these messengers is UNI - PMP, bidirectional.
//      Notice that req/resp normally means travel direction "down".
//      Anyway, here they are flowing upwards as well.
//

class uniADD_PARTYreq : public pfMessenger
{
    public:
        uniADD_PARTYreq(const uniADD_PARTYreq &other_);
        virtual ~uniADD_PARTYreq(void);
        virtual pfMessenger *clone(void);
        static uniADD_PARTYreq *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniADD_PARTYreq(void);
};

class uniADD_PARTYresp : public pfMessenger
{
    public:
        uniADD_PARTYresp(const uniADD_PARTYresp &other_);
        virtual ~uniADD_PARTYresp(void);
        virtual pfMessenger *clone(void);
        static uniADD_PARTYresp *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniADD_PARTYresp(void);
};

class uniADD_PARTYerror : public pfMessenger
{
    public:
        uniADD_PARTYerror(const uniADD_PARTYerror &other_);
        virtual ~uniADD_PARTYerror(void);
        virtual pfMessenger *clone(void);
        static uniADD_PARTYerror *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniADD_PARTYerror(void);
};

class uniDROP_PARTYreq : public pfMessenger
{
    public:
        uniDROP_PARTYreq(const uniDROP_PARTYreq &other_);
        virtual ~uniDROP_PARTYreq(void);
        virtual pfMessenger *clone(void);
        static uniDROP_PARTYreq *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniDROP_PARTYreq(void);
};

class uniDROP_PARTYresp : public pfMessenger
{
    public:
        uniDROP_PARTYresp(const uniDROP_PARTYresp &other_);
        virtual ~uniDROP_PARTYresp(void);
        virtual pfMessenger *clone(void);
        static uniDROP_PARTYresp *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniDROP_PARTYresp(void);
};

class uniSTATUSreq : public pfMessenger
{
    public:
        uniSTATUSreq(const uniSTATUSreq &other_);
        virtual ~uniSTATUSreq(void);
        virtual pfMessenger *clone(void);
        static uniSTATUSreq *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniSTATUSreq(void);
};

class uniSTATUSresp : public pfMessenger
{
    public:
        uniSTATUSresp(const uniSTATUSresp &other_);
        virtual ~uniSTATUSresp(void);
        virtual pfMessenger *clone(void);
        static uniSTATUSresp *create(void);
        virtual void apply(pfState *state_, pfProtocol *protocol_);
    private:
        uniSTATUSresp(void);
};

//----------------------------------------------------------------
// Class: uni*Inputs
//
// Description:
//      Abstract classes to be inherited at (state) classes, which
//      should be capable to get these primitives as input.
//

class uniUpRSNandRRNInputs 
{
    public:
        virtual void uniRESET_ERRORindAct(uniRESET_ERRORind *message_,
                                          pfProtocol *protocol_) = 0;
        virtual void uniRESETconfAct(uniRESETconf *message_,
                                     pfProtocol *protocol_) = 0;
        virtual void uniRESETindAct(uniRESETind *message_,
                                    pfProtocol *protocol_) = 0;
};

class uniUpInputs 
{
    public:
        virtual void uniLINK_ESTABLISHconfAct(uniLINK_ESTABLISHconf *message_,
                                              pfProtocol *protocol_) = 0;
        virtual void uniLINK_ESTABLISHindAct(uniLINK_ESTABLISHind *message_,
                                             pfProtocol *protocol_) = 0;
        virtual void uniLINK_ESTABLISHerrorAct(uniLINK_ESTABLISHerror *message_,
                                               pfProtocol *protocol_) = 0;
        virtual void uniLINK_RELEASEconfAct(uniLINK_RELEASEconf *message_,
                                            pfProtocol *protocol_) = 0;
        virtual void uniLINK_RELEASEindAct(uniLINK_RELEASEind *message_,
                                           pfProtocol *protocol_) = 0;
};

class uniDownRSNInputs
{
    public:
        virtual void uniRESETreqAct(uniRESETreq *message_,
                                    pfProtocol *protocol_) = 0;
};

class uniDownRRNInputs 
{
    public:
        virtual void uniRESETrespAct(uniRESETresp *message_,
                                     pfProtocol *protocol_) = 0;
        virtual void uniRESET_ERRORrespAct(uniRESET_ERRORresp *message_,
                                           pfProtocol *protocol_) = 0;
};

class uniDownInputs 
{
    public:
        virtual void uniLINK_ESTABLISHreqAct(uniLINK_ESTABLISHreq *message_,
                                             pfProtocol *protocol_) = 0;
        virtual void uniLINK_RELEASEreqAct(uniLINK_RELEASEreq *message_,
                                           pfProtocol *protocol_) = 0;
};

class uniPMPInputs
{
    public:
        virtual void uniADD_PARTYreqAct(uniADD_PARTYreq *message_,
                                        pfProtocol *protocol_) = 0;
        virtual void uniADD_PARTYrespAct(uniADD_PARTYresp *message_,
                                         pfProtocol *protocol_) = 0;
        virtual void uniADD_PARTYerrorAct(uniADD_PARTYerror *message_,
                                          pfProtocol *protocol_) = 0;
        virtual void uniDROP_PARTYreqAct(uniDROP_PARTYreq *message_,
                                         pfProtocol *protocol_) = 0;
        virtual void uniDROP_PARTYrespAct(uniDROP_PARTYresp *message_,
                                          pfProtocol *protocol_) = 0;
        virtual void uniSTATUSreqAct(uniSTATUSreq *message_,
                                     pfProtocol *protocol_) = 0;
        virtual void uniSTATUSrespAct(uniSTATUSresp *message_,
                                      pfProtocol *protocol_) = 0;
};

#endif // __UNI_UNIPRIMITIVES_H__