HChordMessage_m.h

//
// Generated file, do not edit! Created by opp_msgc 3.4 from HChordMessage.msg.
//

#ifndef _HCHORDMESSAGE_M_H_
#define _HCHORDMESSAGE_M_H_

#include <omnetpp.h>

// opp_msgc version check
#define MSGC_VERSION 0x0304
#if (MSGC_VERSION!=OMNETPP_VERSION)
#    error Version mismatch! Probably this file was generated by an earlier version of opp_msgc: 'make clean' should help.
#endif

// cplusplus {{ ... }} section:

#include <IPvXAddress.h>
#include <NodeHandle.h>
#include <CommonMessages_m.h>


static const int HCHORDCOMMAND_L = 8;
static const int SUCNUM_L = 8;
static const int FINGER_L = 8;
static const int STEP_L = 8;
static const int DBNODESET_L = 1;
static const int OTHERLOOKUP_L = 1;
static const int PRENODESET_L = 1;
static const int OVERLAY_L=8;


#define HCHORD_L(msg)  (BASEOVERLAY_L(msg) + NODEHANDLE_L*2 + OVERLAY_L*2 )

#define HNEWSUCCESSORHINT_L(msg) (BASEOVERLAY_L(msg) + NODEHANDLE_L*3 + OVERLAY_L*2 )
#define HNOTIFYCALL_L(msg) (HCHORD_L(msg) + DBNODESET_L)
#define HNOTIFYRESPONSE_L(msg) (HCHORD_L(msg) + SUCNUM_L + NODEHANDLE_L + (msg->getSucNodeArraySize() * NODEHANDLE_L) )
#define HJOINCALL_L(msg) (BASEOVERLAY_L(msg) + NODEHANDLE_L*2 + OVERLAY_L*2 )
#define HJOINRESPONSE_L(msg) (BASEOVERLAY_L(msg) + NODEHANDLE_L*2 + OVERLAY_L*2 + SUCNUM_L + NODEHANDLE_L + (msg->getSucNodeArraySize() * NODEHANDLE_L))
#define HSTABILIZECALL_L(msg) ( BASEOVERLAY_L(msg) + NODEHANDLE_L*2 + OVERLAY_L*2)

#define HSTABILIZERESPONSE_L(msg) (HCHORD_L(msg) + NODEHANDLE_L)
#define HFIXFINGERSCALL_L(msg) (BASEOVERLAY_L(msg) + NODEHANDLE_L*2 + OVERLAY_L*2 + FINGER_L)
#define HFIXFINGERSRESPONSE_L(msg) (HCHORD_L(msg) + FINGER_L + (msg->getSucNodeArraySize() * NODEHANDLE_L))


#define JOIN_REQUEST 0
#define JOIN_RESPONSE 1
#define NEW_SUCCESSOR_HINT 2
#define STABILIZE_CALL 3
#define STABILIZE_RESPONSE 4
#define FIXFINGERS_CALL 5
#define FIXFINGERS_RESPONSE 6
#define NOTIFY_CALL 7
#define NOTIFY_RESPONSE 8
#define MIGRATE_REQUEST 9
#define MIGRATE_RESPONSE 10
#define STABILIZE_SUPER_PEER_CALL 11
#define STABILIZE_SUPER_PEER_RESPONSE 12
#define LARGEST_NODE_REQUEST 13
#define LARGEST_NODE_RESPONSE 14
#define CHANGE_PRE 15
#define CHANGE_SUC_REQ 16
#define CHANGE_SUC_RES 17


// end cplusplus


/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message  HChordMessage extends BaseOverlayMessage
 * {
 *     fields:
 * 	NodeHandle src;
 * 	NodeHandle dest;
 * 	int mesg_type;
 * };
 * </pre>
 */
class HChordMessage : public BaseOverlayMessage
{
  protected:
    NodeHandle src_var;
    NodeHandle dest_var;
    int mesg_type_var;

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HChordMessage&);

  public:
    HChordMessage(const char *name=NULL, int kind=0);
    HChordMessage(const HChordMessage& other);
    virtual ~HChordMessage();
    HChordMessage& operator=(const HChordMessage& other);
    virtual cPolymorphic *dup() const {return new HChordMessage(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
    virtual NodeHandle& getSrc();
    virtual const NodeHandle& getSrc() const {return const_cast<HChordMessage*>(this)->getSrc();}
    virtual void setSrc(const NodeHandle& src_var);
    virtual NodeHandle& getDest();
    virtual const NodeHandle& getDest() const {return const_cast<HChordMessage*>(this)->getDest();}
    virtual void setDest(const NodeHandle& dest_var);
    virtual int getMesg_type() const;
    virtual void setMesg_type(int mesg_type_var);
};

inline void doPacking(cCommBuffer *b, HChordMessage& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HChordMessage& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HJoinCall extends HChordMessage
 * {
 *     
 * };
 * </pre>
 */
class HJoinCall : public HChordMessage
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HJoinCall&);

  public:
    HJoinCall(const char *name=NULL, int kind=0);
    HJoinCall(const HJoinCall& other);
    virtual ~HJoinCall();
    HJoinCall& operator=(const HJoinCall& other);
    virtual cPolymorphic *dup() const {return new HJoinCall(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, HJoinCall& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HJoinCall& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HJoinResponse extends HChordMessage
 * {
 *     fields:
 *         int sucNum;    
 *         NodeHandle sucNode[];    
 *         NodeHandle preNode;    
 *         NodeHandle superPeerNode;
 *         NodeHandle superPeerPre;
 * };
 * </pre>
 */
class HJoinResponse : public HChordMessage
{
  protected:
    int sucNum_var;
    NodeHandle *sucNode_var; // array ptr
    unsigned int sucNode_arraysize;
    NodeHandle preNode_var;
    NodeHandle superPeerNode_var;
    NodeHandle superPeerPre_var;

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HJoinResponse&);

  public:
    HJoinResponse(const char *name=NULL, int kind=0);
    HJoinResponse(const HJoinResponse& other);
    virtual ~HJoinResponse();
    HJoinResponse& operator=(const HJoinResponse& other);
    virtual cPolymorphic *dup() const {return new HJoinResponse(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
    virtual int getSucNum() const;
    virtual void setSucNum(int sucNum_var);
    virtual void setSucNodeArraySize(unsigned int size);
    virtual unsigned int getSucNodeArraySize() const;
    virtual NodeHandle& getSucNode(unsigned int k);
    virtual const NodeHandle& getSucNode(unsigned int k) const {return const_cast<HJoinResponse*>(this)->getSucNode(k);}
    virtual void setSucNode(unsigned int k, const NodeHandle& sucNode_var);
    virtual NodeHandle& getPreNode();
    virtual const NodeHandle& getPreNode() const {return const_cast<HJoinResponse*>(this)->getPreNode();}
    virtual void setPreNode(const NodeHandle& preNode_var);
    virtual NodeHandle& getSuperPeerNode();
    virtual const NodeHandle& getSuperPeerNode() const {return const_cast<HJoinResponse*>(this)->getSuperPeerNode();}
    virtual void setSuperPeerNode(const NodeHandle& superPeerNode_var);
    virtual NodeHandle& getSuperPeerPre();
    virtual const NodeHandle& getSuperPeerPre() const {return const_cast<HJoinResponse*>(this)->getSuperPeerPre();}
    virtual void setSuperPeerPre(const NodeHandle& superPeerPre_var);
};

inline void doPacking(cCommBuffer *b, HJoinResponse& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HJoinResponse& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HNotifyCall extends HChordMessage
 * {
 * 
 * };
 * </pre>
 */
class HNotifyCall : public HChordMessage
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HNotifyCall&);

  public:
    HNotifyCall(const char *name=NULL, int kind=0);
    HNotifyCall(const HNotifyCall& other);
    virtual ~HNotifyCall();
    HNotifyCall& operator=(const HNotifyCall& other);
    virtual cPolymorphic *dup() const {return new HNotifyCall(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, HNotifyCall& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HNotifyCall& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HNotifyResponse extends HChordMessage
 * {
 *     fields:
 * 	NodeHandle srcNode;
 * 	NodeHandle sucNode[];
 * 	int sucNum; 
 * };
 * </pre>
 */
class HNotifyResponse : public HChordMessage
{
  protected:
    NodeHandle srcNode_var;
    NodeHandle *sucNode_var; // array ptr
    unsigned int sucNode_arraysize;
    int sucNum_var;

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HNotifyResponse&);

  public:
    HNotifyResponse(const char *name=NULL, int kind=0);
    HNotifyResponse(const HNotifyResponse& other);
    virtual ~HNotifyResponse();
    HNotifyResponse& operator=(const HNotifyResponse& other);
    virtual cPolymorphic *dup() const {return new HNotifyResponse(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
    virtual NodeHandle& getSrcNode();
    virtual const NodeHandle& getSrcNode() const {return const_cast<HNotifyResponse*>(this)->getSrcNode();}
    virtual void setSrcNode(const NodeHandle& srcNode_var);
    virtual void setSucNodeArraySize(unsigned int size);
    virtual unsigned int getSucNodeArraySize() const;
    virtual NodeHandle& getSucNode(unsigned int k);
    virtual const NodeHandle& getSucNode(unsigned int k) const {return const_cast<HNotifyResponse*>(this)->getSucNode(k);}
    virtual void setSucNode(unsigned int k, const NodeHandle& sucNode_var);
    virtual int getSucNum() const;
    virtual void setSucNum(int sucNum_var);
};

inline void doPacking(cCommBuffer *b, HNotifyResponse& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HNotifyResponse& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HNewSuccessorHintMsg  extends HChordMessage
 * {
 *     fields:
 * 	NodeHandle pre;
 * }
 * </pre>
 */
class HNewSuccessorHintMsg : public HChordMessage
{
  protected:
    NodeHandle pre_var;

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HNewSuccessorHintMsg&);

  public:
    HNewSuccessorHintMsg(const char *name=NULL, int kind=0);
    HNewSuccessorHintMsg(const HNewSuccessorHintMsg& other);
    virtual ~HNewSuccessorHintMsg();
    HNewSuccessorHintMsg& operator=(const HNewSuccessorHintMsg& other);
    virtual cPolymorphic *dup() const {return new HNewSuccessorHintMsg(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
    virtual NodeHandle& getPre();
    virtual const NodeHandle& getPre() const {return const_cast<HNewSuccessorHintMsg*>(this)->getPre();}
    virtual void setPre(const NodeHandle& pre_var);
};

inline void doPacking(cCommBuffer *b, HNewSuccessorHintMsg& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HNewSuccessorHintMsg& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HStabilizeCall extends HChordMessage
 * {
 * 
 * };
 * </pre>
 */
class HStabilizeCall : public HChordMessage
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HStabilizeCall&);

  public:
    HStabilizeCall(const char *name=NULL, int kind=0);
    HStabilizeCall(const HStabilizeCall& other);
    virtual ~HStabilizeCall();
    HStabilizeCall& operator=(const HStabilizeCall& other);
    virtual cPolymorphic *dup() const {return new HStabilizeCall(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, HStabilizeCall& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HStabilizeCall& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HStabilizeResponse extends HChordMessage
 * {
 *     fields:
 * 	NodeHandle pre;
 * };
 * </pre>
 */
class HStabilizeResponse : public HChordMessage
{
  protected:
    NodeHandle pre_var;

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HStabilizeResponse&);

  public:
    HStabilizeResponse(const char *name=NULL, int kind=0);
    HStabilizeResponse(const HStabilizeResponse& other);
    virtual ~HStabilizeResponse();
    HStabilizeResponse& operator=(const HStabilizeResponse& other);
    virtual cPolymorphic *dup() const {return new HStabilizeResponse(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
    virtual NodeHandle& getPre();
    virtual const NodeHandle& getPre() const {return const_cast<HStabilizeResponse*>(this)->getPre();}
    virtual void setPre(const NodeHandle& pre_var);
};

inline void doPacking(cCommBuffer *b, HStabilizeResponse& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HStabilizeResponse& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HFixfingersCall extends HChordMessage
 * {
 *     fields: 
 * 	int finger;
 * 	OverlayKey lookupKey;
 * };
 * </pre>
 */
class HFixfingersCall : public HChordMessage
{
  protected:
    int finger_var;
    OverlayKey lookupKey_var;

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HFixfingersCall&);

  public:
    HFixfingersCall(const char *name=NULL, int kind=0);
    HFixfingersCall(const HFixfingersCall& other);
    virtual ~HFixfingersCall();
    HFixfingersCall& operator=(const HFixfingersCall& other);
    virtual cPolymorphic *dup() const {return new HFixfingersCall(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
    virtual int getFinger() const;
    virtual void setFinger(int finger_var);
    virtual OverlayKey& getLookupKey();
    virtual const OverlayKey& getLookupKey() const {return const_cast<HFixfingersCall*>(this)->getLookupKey();}
    virtual void setLookupKey(const OverlayKey& lookupKey_var);
};

inline void doPacking(cCommBuffer *b, HFixfingersCall& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HFixfingersCall& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HFixfingersResponse extends HChordMessage
 * {
 *     fields:
 * 	int finger;
 * 	NodeHandle sucNode;
 * };
 * </pre>
 */
class HFixfingersResponse : public HChordMessage
{
  protected:
    int finger_var;
    NodeHandle sucNode_var;

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HFixfingersResponse&);

  public:
    HFixfingersResponse(const char *name=NULL, int kind=0);
    HFixfingersResponse(const HFixfingersResponse& other);
    virtual ~HFixfingersResponse();
    HFixfingersResponse& operator=(const HFixfingersResponse& other);
    virtual cPolymorphic *dup() const {return new HFixfingersResponse(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
    virtual int getFinger() const;
    virtual void setFinger(int finger_var);
    virtual NodeHandle& getSucNode();
    virtual const NodeHandle& getSucNode() const {return const_cast<HFixfingersResponse*>(this)->getSucNode();}
    virtual void setSucNode(const NodeHandle& sucNode_var);
};

inline void doPacking(cCommBuffer *b, HFixfingersResponse& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HFixfingersResponse& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HMigrateRequest extends HChordMessage
 * {
 * 	
 * };
 * </pre>
 */
class HMigrateRequest : public HChordMessage
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HMigrateRequest&);

  public:
    HMigrateRequest(const char *name=NULL, int kind=0);
    HMigrateRequest(const HMigrateRequest& other);
    virtual ~HMigrateRequest();
    HMigrateRequest& operator=(const HMigrateRequest& other);
    virtual cPolymorphic *dup() const {return new HMigrateRequest(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, HMigrateRequest& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HMigrateRequest& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HMigrateResponse extends HChordMessage
 * {
 * 	
 * };
 * </pre>
 */
class HMigrateResponse : public HChordMessage
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HMigrateResponse&);

  public:
    HMigrateResponse(const char *name=NULL, int kind=0);
    HMigrateResponse(const HMigrateResponse& other);
    virtual ~HMigrateResponse();
    HMigrateResponse& operator=(const HMigrateResponse& other);
    virtual cPolymorphic *dup() const {return new HMigrateResponse(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, HMigrateResponse& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HMigrateResponse& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HStabilizeSuperPeerCall extends HChordMessage
 * {
 * 	fields:
 * 	bool largest;
 * 	NodeHandle Suc;
 * };
 * </pre>
 */
class HStabilizeSuperPeerCall : public HChordMessage
{
  protected:
    bool largest_var;
    NodeHandle Suc_var;

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HStabilizeSuperPeerCall&);

  public:
    HStabilizeSuperPeerCall(const char *name=NULL, int kind=0);
    HStabilizeSuperPeerCall(const HStabilizeSuperPeerCall& other);
    virtual ~HStabilizeSuperPeerCall();
    HStabilizeSuperPeerCall& operator=(const HStabilizeSuperPeerCall& other);
    virtual cPolymorphic *dup() const {return new HStabilizeSuperPeerCall(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
    virtual bool getLargest() const;
    virtual void setLargest(bool largest_var);
    virtual NodeHandle& getSuc();
    virtual const NodeHandle& getSuc() const {return const_cast<HStabilizeSuperPeerCall*>(this)->getSuc();}
    virtual void setSuc(const NodeHandle& Suc_var);
};

inline void doPacking(cCommBuffer *b, HStabilizeSuperPeerCall& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HStabilizeSuperPeerCall& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HStabilizeSuperPeerResponse extends HChordMessage
 * {
 *     fields:
 * 	NodeHandle strongPeers[];
 * 	NodeHandle preNode;
 * 	int num;
 * };
 * </pre>
 */
class HStabilizeSuperPeerResponse : public HChordMessage
{
  protected:
    NodeHandle *strongPeers_var; // array ptr
    unsigned int strongPeers_arraysize;
    NodeHandle preNode_var;
    int num_var;

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HStabilizeSuperPeerResponse&);

  public:
    HStabilizeSuperPeerResponse(const char *name=NULL, int kind=0);
    HStabilizeSuperPeerResponse(const HStabilizeSuperPeerResponse& other);
    virtual ~HStabilizeSuperPeerResponse();
    HStabilizeSuperPeerResponse& operator=(const HStabilizeSuperPeerResponse& other);
    virtual cPolymorphic *dup() const {return new HStabilizeSuperPeerResponse(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
    virtual void setStrongPeersArraySize(unsigned int size);
    virtual unsigned int getStrongPeersArraySize() const;
    virtual NodeHandle& getStrongPeers(unsigned int k);
    virtual const NodeHandle& getStrongPeers(unsigned int k) const {return const_cast<HStabilizeSuperPeerResponse*>(this)->getStrongPeers(k);}
    virtual void setStrongPeers(unsigned int k, const NodeHandle& strongPeers_var);
    virtual NodeHandle& getPreNode();
    virtual const NodeHandle& getPreNode() const {return const_cast<HStabilizeSuperPeerResponse*>(this)->getPreNode();}
    virtual void setPreNode(const NodeHandle& preNode_var);
    virtual int getNum() const;
    virtual void setNum(int num_var);
};

inline void doPacking(cCommBuffer *b, HStabilizeSuperPeerResponse& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HStabilizeSuperPeerResponse& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HLargestNodeRequest extends HChordMessage
 * {
 * 
 * };
 * </pre>
 */
class HLargestNodeRequest : public HChordMessage
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HLargestNodeRequest&);

  public:
    HLargestNodeRequest(const char *name=NULL, int kind=0);
    HLargestNodeRequest(const HLargestNodeRequest& other);
    virtual ~HLargestNodeRequest();
    HLargestNodeRequest& operator=(const HLargestNodeRequest& other);
    virtual cPolymorphic *dup() const {return new HLargestNodeRequest(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, HLargestNodeRequest& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HLargestNodeRequest& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HLargestNodeResponse extends HChordMessage
 * {
 * 	fields:
 * 	NodeHandle node;
 * 	NodeHandle suc;
 * };
 * </pre>
 */
class HLargestNodeResponse : public HChordMessage
{
  protected:
    NodeHandle node_var;
    NodeHandle suc_var;

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HLargestNodeResponse&);

  public:
    HLargestNodeResponse(const char *name=NULL, int kind=0);
    HLargestNodeResponse(const HLargestNodeResponse& other);
    virtual ~HLargestNodeResponse();
    HLargestNodeResponse& operator=(const HLargestNodeResponse& other);
    virtual cPolymorphic *dup() const {return new HLargestNodeResponse(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
    virtual NodeHandle& getNode();
    virtual const NodeHandle& getNode() const {return const_cast<HLargestNodeResponse*>(this)->getNode();}
    virtual void setNode(const NodeHandle& node_var);
    virtual NodeHandle& getSuc();
    virtual const NodeHandle& getSuc() const {return const_cast<HLargestNodeResponse*>(this)->getSuc();}
    virtual void setSuc(const NodeHandle& suc_var);
};

inline void doPacking(cCommBuffer *b, HLargestNodeResponse& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HLargestNodeResponse& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HChangePredecessor extends HChordMessage
 * {
 * 	fields:
 * 	NodeHandle newPre;
 * };
 * </pre>
 */
class HChangePredecessor : public HChordMessage
{
  protected:
    NodeHandle newPre_var;

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HChangePredecessor&);

  public:
    HChangePredecessor(const char *name=NULL, int kind=0);
    HChangePredecessor(const HChangePredecessor& other);
    virtual ~HChangePredecessor();
    HChangePredecessor& operator=(const HChangePredecessor& other);
    virtual cPolymorphic *dup() const {return new HChangePredecessor(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
    virtual NodeHandle& getNewPre();
    virtual const NodeHandle& getNewPre() const {return const_cast<HChangePredecessor*>(this)->getNewPre();}
    virtual void setNewPre(const NodeHandle& newPre_var);
};

inline void doPacking(cCommBuffer *b, HChangePredecessor& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HChangePredecessor& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HChangeSuccessorRequest extends HChordMessage
 * {
 * 	fields:
 * 	NodeHandle newSuc;
 * 	NodeHandle newPre;
 * }
 * </pre>
 */
class HChangeSuccessorRequest : public HChordMessage
{
  protected:
    NodeHandle newSuc_var;
    NodeHandle newPre_var;

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HChangeSuccessorRequest&);

  public:
    HChangeSuccessorRequest(const char *name=NULL, int kind=0);
    HChangeSuccessorRequest(const HChangeSuccessorRequest& other);
    virtual ~HChangeSuccessorRequest();
    HChangeSuccessorRequest& operator=(const HChangeSuccessorRequest& other);
    virtual cPolymorphic *dup() const {return new HChangeSuccessorRequest(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
    virtual NodeHandle& getNewSuc();
    virtual const NodeHandle& getNewSuc() const {return const_cast<HChangeSuccessorRequest*>(this)->getNewSuc();}
    virtual void setNewSuc(const NodeHandle& newSuc_var);
    virtual NodeHandle& getNewPre();
    virtual const NodeHandle& getNewPre() const {return const_cast<HChangeSuccessorRequest*>(this)->getNewPre();}
    virtual void setNewPre(const NodeHandle& newPre_var);
};

inline void doPacking(cCommBuffer *b, HChangeSuccessorRequest& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HChangeSuccessorRequest& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message HChangeSuccessorResponse extends HChordMessage
 * {
 * 	fields:
 * 	NodeHandle newSuc;
 * 	NodeHandle newPre;
 * }
 * </pre>
 */
class HChangeSuccessorResponse : public HChordMessage
{
  protected:
    NodeHandle newSuc_var;
    NodeHandle newPre_var;

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const HChangeSuccessorResponse&);

  public:
    HChangeSuccessorResponse(const char *name=NULL, int kind=0);
    HChangeSuccessorResponse(const HChangeSuccessorResponse& other);
    virtual ~HChangeSuccessorResponse();
    HChangeSuccessorResponse& operator=(const HChangeSuccessorResponse& other);
    virtual cPolymorphic *dup() const {return new HChangeSuccessorResponse(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
    virtual NodeHandle& getNewSuc();
    virtual const NodeHandle& getNewSuc() const {return const_cast<HChangeSuccessorResponse*>(this)->getNewSuc();}
    virtual void setNewSuc(const NodeHandle& newSuc_var);
    virtual NodeHandle& getNewPre();
    virtual const NodeHandle& getNewPre() const {return const_cast<HChangeSuccessorResponse*>(this)->getNewPre();}
    virtual void setNewPre(const NodeHandle& newPre_var);
};

inline void doPacking(cCommBuffer *b, HChangeSuccessorResponse& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, HChangeSuccessorResponse& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message UHJoinCall extends HJoinCall
 * {
 * 	fields:
 * 	NodeHandle LowerNewSuc;
 * 
 * };
 * </pre>
 */
class UHJoinCall : public HJoinCall
{
  protected:
    NodeHandle LowerNewSuc_var;

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const UHJoinCall&);

  public:
    UHJoinCall(const char *name=NULL, int kind=0);
    UHJoinCall(const UHJoinCall& other);
    virtual ~UHJoinCall();
    UHJoinCall& operator=(const UHJoinCall& other);
    virtual cPolymorphic *dup() const {return new UHJoinCall(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
    virtual NodeHandle& getLowerNewSuc();
    virtual const NodeHandle& getLowerNewSuc() const {return const_cast<UHJoinCall*>(this)->getLowerNewSuc();}
    virtual void setLowerNewSuc(const NodeHandle& LowerNewSuc_var);
};

inline void doPacking(cCommBuffer *b, UHJoinCall& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, UHJoinCall& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message UHJoinResponse extends HJoinResponse
 * {
 * 	fields:
 * 		NodeHandle LowerNewSuc;
 * 
 * };
 * </pre>
 */
class UHJoinResponse : public HJoinResponse
{
  protected:
    NodeHandle LowerNewSuc_var;

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const UHJoinResponse&);

  public:
    UHJoinResponse(const char *name=NULL, int kind=0);
    UHJoinResponse(const UHJoinResponse& other);
    virtual ~UHJoinResponse();
    UHJoinResponse& operator=(const UHJoinResponse& other);
    virtual cPolymorphic *dup() const {return new UHJoinResponse(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
    virtual NodeHandle& getLowerNewSuc();
    virtual const NodeHandle& getLowerNewSuc() const {return const_cast<UHJoinResponse*>(this)->getLowerNewSuc();}
    virtual void setLowerNewSuc(const NodeHandle& LowerNewSuc_var);
};

inline void doPacking(cCommBuffer *b, UHJoinResponse& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, UHJoinResponse& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message UHNotifyCall extends HNotifyCall
 * {
 * 
 * };
 * </pre>
 */
class UHNotifyCall : public HNotifyCall
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const UHNotifyCall&);

  public:
    UHNotifyCall(const char *name=NULL, int kind=0);
    UHNotifyCall(const UHNotifyCall& other);
    virtual ~UHNotifyCall();
    UHNotifyCall& operator=(const UHNotifyCall& other);
    virtual cPolymorphic *dup() const {return new UHNotifyCall(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, UHNotifyCall& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, UHNotifyCall& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message UHNotifyResponse extends HNotifyResponse
 * {
 * 
 * };
 * </pre>
 */
class UHNotifyResponse : public HNotifyResponse
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const UHNotifyResponse&);

  public:
    UHNotifyResponse(const char *name=NULL, int kind=0);
    UHNotifyResponse(const UHNotifyResponse& other);
    virtual ~UHNotifyResponse();
    UHNotifyResponse& operator=(const UHNotifyResponse& other);
    virtual cPolymorphic *dup() const {return new UHNotifyResponse(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, UHNotifyResponse& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, UHNotifyResponse& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message UHStabilizeCall extends HStabilizeCall
 * {
 * 
 * };
 * </pre>
 */
class UHStabilizeCall : public HStabilizeCall
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const UHStabilizeCall&);

  public:
    UHStabilizeCall(const char *name=NULL, int kind=0);
    UHStabilizeCall(const UHStabilizeCall& other);
    virtual ~UHStabilizeCall();
    UHStabilizeCall& operator=(const UHStabilizeCall& other);
    virtual cPolymorphic *dup() const {return new UHStabilizeCall(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, UHStabilizeCall& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, UHStabilizeCall& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message UHStabilizeResponse extends HStabilizeResponse
 * {
 *     
 * };
 * </pre>
 */
class UHStabilizeResponse : public HStabilizeResponse
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const UHStabilizeResponse&);

  public:
    UHStabilizeResponse(const char *name=NULL, int kind=0);
    UHStabilizeResponse(const UHStabilizeResponse& other);
    virtual ~UHStabilizeResponse();
    UHStabilizeResponse& operator=(const UHStabilizeResponse& other);
    virtual cPolymorphic *dup() const {return new UHStabilizeResponse(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, UHStabilizeResponse& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, UHStabilizeResponse& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message UHFixfingersCall extends HFixfingersCall
 * {
 *    
 * };
 * </pre>
 */
class UHFixfingersCall : public HFixfingersCall
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const UHFixfingersCall&);

  public:
    UHFixfingersCall(const char *name=NULL, int kind=0);
    UHFixfingersCall(const UHFixfingersCall& other);
    virtual ~UHFixfingersCall();
    UHFixfingersCall& operator=(const UHFixfingersCall& other);
    virtual cPolymorphic *dup() const {return new UHFixfingersCall(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, UHFixfingersCall& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, UHFixfingersCall& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message UHFixfingersResponse extends HFixfingersResponse
 * {
 *     
 * };
 * </pre>
 */
class UHFixfingersResponse : public HFixfingersResponse
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const UHFixfingersResponse&);

  public:
    UHFixfingersResponse(const char *name=NULL, int kind=0);
    UHFixfingersResponse(const UHFixfingersResponse& other);
    virtual ~UHFixfingersResponse();
    UHFixfingersResponse& operator=(const UHFixfingersResponse& other);
    virtual cPolymorphic *dup() const {return new UHFixfingersResponse(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, UHFixfingersResponse& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, UHFixfingersResponse& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message UHNewSuccessorHintMsg  extends  HNewSuccessorHintMsg
 * {
 *     
 * };
 * </pre>
 */
class UHNewSuccessorHintMsg : public HNewSuccessorHintMsg
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const UHNewSuccessorHintMsg&);

  public:
    UHNewSuccessorHintMsg(const char *name=NULL, int kind=0);
    UHNewSuccessorHintMsg(const UHNewSuccessorHintMsg& other);
    virtual ~UHNewSuccessorHintMsg();
    UHNewSuccessorHintMsg& operator=(const UHNewSuccessorHintMsg& other);
    virtual cPolymorphic *dup() const {return new UHNewSuccessorHintMsg(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, UHNewSuccessorHintMsg& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, UHNewSuccessorHintMsg& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message LHStabilizeCall extends HStabilizeCall
 * {
 * 
 * };
 * </pre>
 */
class LHStabilizeCall : public HStabilizeCall
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const LHStabilizeCall&);

  public:
    LHStabilizeCall(const char *name=NULL, int kind=0);
    LHStabilizeCall(const LHStabilizeCall& other);
    virtual ~LHStabilizeCall();
    LHStabilizeCall& operator=(const LHStabilizeCall& other);
    virtual cPolymorphic *dup() const {return new LHStabilizeCall(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, LHStabilizeCall& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, LHStabilizeCall& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message LHStabilizeResponse extends HStabilizeResponse
 * {
 *     
 * };
 * </pre>
 */
class LHStabilizeResponse : public HStabilizeResponse
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const LHStabilizeResponse&);

  public:
    LHStabilizeResponse(const char *name=NULL, int kind=0);
    LHStabilizeResponse(const LHStabilizeResponse& other);
    virtual ~LHStabilizeResponse();
    LHStabilizeResponse& operator=(const LHStabilizeResponse& other);
    virtual cPolymorphic *dup() const {return new LHStabilizeResponse(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, LHStabilizeResponse& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, LHStabilizeResponse& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message LHFixfingersCall extends UHFixfingersCall
 * {
 *    
 * };
 * </pre>
 */
class LHFixfingersCall : public UHFixfingersCall
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const LHFixfingersCall&);

  public:
    LHFixfingersCall(const char *name=NULL, int kind=0);
    LHFixfingersCall(const LHFixfingersCall& other);
    virtual ~LHFixfingersCall();
    LHFixfingersCall& operator=(const LHFixfingersCall& other);
    virtual cPolymorphic *dup() const {return new LHFixfingersCall(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, LHFixfingersCall& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, LHFixfingersCall& obj) {obj.netUnpack(b);}

/**
 * Class generated from <tt>HChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * message LHFixfingersResponse extends HFixfingersResponse
 * {
 *     
 * };
 * </pre>
 */
class LHFixfingersResponse : public HFixfingersResponse
{
  protected:

    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const LHFixfingersResponse&);

  public:
    LHFixfingersResponse(const char *name=NULL, int kind=0);
    LHFixfingersResponse(const LHFixfingersResponse& other);
    virtual ~LHFixfingersResponse();
    LHFixfingersResponse& operator=(const LHFixfingersResponse& other);
    virtual cPolymorphic *dup() const {return new LHFixfingersResponse(*this);}
    virtual void netPack(cCommBuffer *b);
    virtual void netUnpack(cCommBuffer *b);

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, LHFixfingersResponse& obj) {obj.netPack(b);}
inline void doUnpacking(cCommBuffer *b, LHFixfingersResponse& obj) {obj.netUnpack(b);}

#endif // _HCHORDMESSAGE_M_H_