//
// Generated file, do not edit! Created by opp_msgc 4.1 from overlay/mychord/MyChordMessage.msg.
//

#ifndef _MYCHORDMESSAGE_M_H_
#define _MYCHORDMESSAGE_M_H_

#include <omnetpp.h>

// opp_msgc version check
#define MSGC_VERSION 0x0401
#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 {{
#include <IPvXAddress.h>
#include <NodeHandle.h>
#include <TransportAddress.h>
#include <CommonMessages_m.h>



static const int CHORDCOMMAND_L = 8;
static const int SUCNUM_L = 8;
static const int FINGER_L = 8;
static const int STEP_L = 8;
static const int PRENODESET_L = 1;

#define NEWSUCCESSORHINT_L(msg) (BASEOVERLAY_L(msg) + CHORDCOMMAND_L + \
                                 2*NODEHANDLE_L)
#define NOTIFYCALL_L(msg) (BASECALL_L(msg))
#define NOTIFYRESPONSE_L(msg) (BASERESPONSE_L(msg) + SUCNUM_L + NODEHANDLE_L +\
			      (msg->getSucNodeArraySize() * NODEHANDLE_L) +\
                  PRENODESET_L)
#define JOINCALL_L(msg) BASECALL_L(msg)
#define JOINRESPONSE_L(msg) (BASERESPONSE_L(msg) + SUCNUM_L + NODEHANDLE_L +\
                             (msg->getSucNodeArraySize() * NODEHANDLE_L))
#define STABILIZECALL_L(msg) BASECALL_L(msg)
#define STABILIZERESPONSE_L(msg) (BASERESPONSE_L(msg) + NODEHANDLE_L)
#define FIXFINGERSCALL_L(msg) (BASECALL_L(msg) + FINGER_L)
#define FIXFINGERSRESPONSE_L(msg) (BASERESPONSE_L(msg) + FINGER_L + \
                                   NODEHANDLE_L + SUCNUM_L + \
                                   (msg->getSucNodeArraySize() * NODEHANDLE_L))
#define DEBRUIJNCALL_L(msg) (BASECALL_L(msg) + KEY_L)
#define DEBRUIJNRESPONSE_L(msg) (BASERESPONSE_L(msg) + SUCNUM_L + NODEHANDLE_L + \
				 (msg->getSucNodeArraySize() * NODEHANDLE_L))
// }}



/**
 * Enum generated from <tt>overlay/mychord/MyChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * enum ChordCommand
 * {
 *     NEWSUCCESSORHINT = 0;
 * 	FINDGROUPMEMBER = 1;
 * 	FINDGROUPMEMBERREPLY = 2;
 * }
 * </pre>
 */
enum ChordCommand {
    NEWSUCCESSORHINT = 0,
    FINDGROUPMEMBER = 1,
    FINDGROUPMEMBERREPLY = 2
};

/**
 * Class generated from <tt>overlay/mychord/MyChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * packet MyChordMessage extends BaseOverlayMessage
 * {
 *     int command enum(ChordCommand);    
 * }
 * </pre>
 */
class MyChordMessage : public ::BaseOverlayMessage
{
  protected:
    int command_var;

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

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

    // field getter/setter methods
    virtual int getCommand() const;
    virtual void setCommand(int command_var);
};

inline void doPacking(cCommBuffer *b, MyChordMessage& obj) {obj.parsimPack(b);}
inline void doUnpacking(cCommBuffer *b, MyChordMessage& obj) {obj.parsimUnpack(b);}

/**
 * Class generated from <tt>overlay/mychord/MyChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * packet MyNewSuccessorHintMessage extends MyChordMessage
 * {
 *     NodeHandle srcNode;    	
 *     NodeHandle preNode;    	
 * 	int srcGroupId;			
 * 	int preGroupId;			
 * }
 * </pre>
 */
class MyNewSuccessorHintMessage : public ::MyChordMessage
{
  protected:
    ::NodeHandle srcNode_var;
    ::NodeHandle preNode_var;
    int srcGroupId_var;
    int preGroupId_var;

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

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

    // field getter/setter methods
    virtual NodeHandle& getSrcNode();
    virtual const NodeHandle& getSrcNode() const {return const_cast<MyNewSuccessorHintMessage*>(this)->getSrcNode();}
    virtual void setSrcNode(const NodeHandle& srcNode_var);
    virtual NodeHandle& getPreNode();
    virtual const NodeHandle& getPreNode() const {return const_cast<MyNewSuccessorHintMessage*>(this)->getPreNode();}
    virtual void setPreNode(const NodeHandle& preNode_var);
    virtual int getSrcGroupId() const;
    virtual void setSrcGroupId(int srcGroupId_var);
    virtual int getPreGroupId() const;
    virtual void setPreGroupId(int preGroupId_var);
};

inline void doPacking(cCommBuffer *b, MyNewSuccessorHintMessage& obj) {obj.parsimPack(b);}
inline void doUnpacking(cCommBuffer *b, MyNewSuccessorHintMessage& obj) {obj.parsimUnpack(b);}

/**
 * Class generated from <tt>overlay/mychord/MyChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * packet MyNotifyCall extends BaseCallMessage
 * {
 *     TransportAddress failed = TransportAddress::UNSPECIFIED_NODE;
 * 	int srcGroupId;				
 * }
 * </pre>
 */
class MyNotifyCall : public ::BaseCallMessage
{
  protected:
    ::TransportAddress failed_var;
    int srcGroupId_var;

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

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

    // field getter/setter methods
    virtual TransportAddress& getFailed();
    virtual const TransportAddress& getFailed() const {return const_cast<MyNotifyCall*>(this)->getFailed();}
    virtual void setFailed(const TransportAddress& failed_var);
    virtual int getSrcGroupId() const;
    virtual void setSrcGroupId(int srcGroupId_var);
};

inline void doPacking(cCommBuffer *b, MyNotifyCall& obj) {obj.parsimPack(b);}
inline void doUnpacking(cCommBuffer *b, MyNotifyCall& obj) {obj.parsimUnpack(b);}

/**
 * Class generated from <tt>overlay/mychord/MyChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * packet MyNotifyResponse extends BaseResponseMessage
 * {
 *     int sucNum;    					
 * 	int srcGroupId; 				
 *    	NodeHandle sucNode[];   		
 *     int sucGroupId[];    			
 *     NodeHandle preNode;    			
 * 	int preGroupId;					
 *     bool preNodeSet; 				
 * }
 * </pre>
 */
class MyNotifyResponse : public ::BaseResponseMessage
{
  protected:
    int sucNum_var;
    int srcGroupId_var;
    ::NodeHandle *sucNode_var; // array ptr
    unsigned int sucNode_arraysize;
    int *sucGroupId_var; // array ptr
    unsigned int sucGroupId_arraysize;
    ::NodeHandle preNode_var;
    int preGroupId_var;
    bool preNodeSet_var;

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

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

    // field getter/setter methods
    virtual int getSucNum() const;
    virtual void setSucNum(int sucNum_var);
    virtual int getSrcGroupId() const;
    virtual void setSrcGroupId(int srcGroupId_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<MyNotifyResponse*>(this)->getSucNode(k);}
    virtual void setSucNode(unsigned int k, const NodeHandle& sucNode_var);
    virtual void setSucGroupIdArraySize(unsigned int size);
    virtual unsigned int getSucGroupIdArraySize() const;
    virtual int getSucGroupId(unsigned int k) const;
    virtual void setSucGroupId(unsigned int k, int sucGroupId_var);
    virtual NodeHandle& getPreNode();
    virtual const NodeHandle& getPreNode() const {return const_cast<MyNotifyResponse*>(this)->getPreNode();}
    virtual void setPreNode(const NodeHandle& preNode_var);
    virtual int getPreGroupId() const;
    virtual void setPreGroupId(int preGroupId_var);
    virtual bool getPreNodeSet() const;
    virtual void setPreNodeSet(bool preNodeSet_var);
};

inline void doPacking(cCommBuffer *b, MyNotifyResponse& obj) {obj.parsimPack(b);}
inline void doUnpacking(cCommBuffer *b, MyNotifyResponse& obj) {obj.parsimUnpack(b);}

/**
 * Class generated from <tt>overlay/mychord/MyChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * packet MyJoinCall extends BaseCallMessage
 * {
 * 	int groupId;					
 * }
 * </pre>
 */
class MyJoinCall : public ::BaseCallMessage
{
  protected:
    int groupId_var;

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

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

    // field getter/setter methods
    virtual int getGroupId() const;
    virtual void setGroupId(int groupId_var);
};

inline void doPacking(cCommBuffer *b, MyJoinCall& obj) {obj.parsimPack(b);}
inline void doUnpacking(cCommBuffer *b, MyJoinCall& obj) {obj.parsimUnpack(b);}

/**
 * Class generated from <tt>overlay/mychord/MyChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * packet MyJoinResponse extends BaseResponseMessage
 * {
 *     int sucNum;    					
 *     NodeHandle sucNode[];    		
 *     int sucGroupId[];   			
 *     NodeHandle preNode;    			
 * 	int srcGroupId;					
 * 	int preGroupId;					
 * 
 * }
 * </pre>
 */
class MyJoinResponse : public ::BaseResponseMessage
{
  protected:
    int sucNum_var;
    ::NodeHandle *sucNode_var; // array ptr
    unsigned int sucNode_arraysize;
    int *sucGroupId_var; // array ptr
    unsigned int sucGroupId_arraysize;
    ::NodeHandle preNode_var;
    int srcGroupId_var;
    int preGroupId_var;

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

  public:
    MyJoinResponse(const char *name=NULL, int kind=0);
    MyJoinResponse(const MyJoinResponse& other);
    virtual ~MyJoinResponse();
    MyJoinResponse& operator=(const MyJoinResponse& other);
    virtual MyJoinResponse *dup() const {return new MyJoinResponse(*this);}
    virtual void parsimPack(cCommBuffer *b);
    virtual void parsimUnpack(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<MyJoinResponse*>(this)->getSucNode(k);}
    virtual void setSucNode(unsigned int k, const NodeHandle& sucNode_var);
    virtual void setSucGroupIdArraySize(unsigned int size);
    virtual unsigned int getSucGroupIdArraySize() const;
    virtual int getSucGroupId(unsigned int k) const;
    virtual void setSucGroupId(unsigned int k, int sucGroupId_var);
    virtual NodeHandle& getPreNode();
    virtual const NodeHandle& getPreNode() const {return const_cast<MyJoinResponse*>(this)->getPreNode();}
    virtual void setPreNode(const NodeHandle& preNode_var);
    virtual int getSrcGroupId() const;
    virtual void setSrcGroupId(int srcGroupId_var);
    virtual int getPreGroupId() const;
    virtual void setPreGroupId(int preGroupId_var);
};

inline void doPacking(cCommBuffer *b, MyJoinResponse& obj) {obj.parsimPack(b);}
inline void doUnpacking(cCommBuffer *b, MyJoinResponse& obj) {obj.parsimUnpack(b);}

/**
 * Class generated from <tt>overlay/mychord/MyChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * packet MyStabilizeCall extends BaseCallMessage
 * {
 * }
 * </pre>
 */
class MyStabilizeCall : public ::BaseCallMessage
{
  protected:

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

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

    // field getter/setter methods
};

inline void doPacking(cCommBuffer *b, MyStabilizeCall& obj) {obj.parsimPack(b);}
inline void doUnpacking(cCommBuffer *b, MyStabilizeCall& obj) {obj.parsimUnpack(b);}

/**
 * Class generated from <tt>overlay/mychord/MyChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * packet MyStabilizeResponse extends BaseResponseMessage
 * {
 *     NodeHandle preNode;    	
 * 	int srcGroupId;			
 * 	int preGroupId;			
 * }
 * </pre>
 */
class MyStabilizeResponse : public ::BaseResponseMessage
{
  protected:
    ::NodeHandle preNode_var;
    int srcGroupId_var;
    int preGroupId_var;

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

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

    // field getter/setter methods
    virtual NodeHandle& getPreNode();
    virtual const NodeHandle& getPreNode() const {return const_cast<MyStabilizeResponse*>(this)->getPreNode();}
    virtual void setPreNode(const NodeHandle& preNode_var);
    virtual int getSrcGroupId() const;
    virtual void setSrcGroupId(int srcGroupId_var);
    virtual int getPreGroupId() const;
    virtual void setPreGroupId(int preGroupId_var);
};

inline void doPacking(cCommBuffer *b, MyStabilizeResponse& obj) {obj.parsimPack(b);}
inline void doUnpacking(cCommBuffer *b, MyStabilizeResponse& obj) {obj.parsimUnpack(b);}

/**
 * Class generated from <tt>overlay/mychord/MyChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * packet MyFixfingersCall extends BaseCallMessage
 * {
 *     unsigned int finger;    			
 * 	int groupId;			
 * }
 * </pre>
 */
class MyFixfingersCall : public ::BaseCallMessage
{
  protected:
    unsigned int finger_var;
    int groupId_var;

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

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

    // field getter/setter methods
    virtual unsigned int getFinger() const;
    virtual void setFinger(unsigned int finger_var);
    virtual int getGroupId() const;
    virtual void setGroupId(int groupId_var);
};

inline void doPacking(cCommBuffer *b, MyFixfingersCall& obj) {obj.parsimPack(b);}
inline void doUnpacking(cCommBuffer *b, MyFixfingersCall& obj) {obj.parsimUnpack(b);}

/**
 * Class generated from <tt>overlay/mychord/MyChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * packet MyFixfingersResponse extends BaseResponseMessage
 * {
 *     int finger;    					
 *     NodeHandle sucNode[];    		
 *     int sucGroupId[];   			
 * }
 * </pre>
 */
class MyFixfingersResponse : public ::BaseResponseMessage
{
  protected:
    int finger_var;
    ::NodeHandle *sucNode_var; // array ptr
    unsigned int sucNode_arraysize;
    int *sucGroupId_var; // array ptr
    unsigned int sucGroupId_arraysize;

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

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

    // field getter/setter methods
    virtual int getFinger() const;
    virtual void setFinger(int finger_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<MyFixfingersResponse*>(this)->getSucNode(k);}
    virtual void setSucNode(unsigned int k, const NodeHandle& sucNode_var);
    virtual void setSucGroupIdArraySize(unsigned int size);
    virtual unsigned int getSucGroupIdArraySize() const;
    virtual int getSucGroupId(unsigned int k) const;
    virtual void setSucGroupId(unsigned int k, int sucGroupId_var);
};

inline void doPacking(cCommBuffer *b, MyFixfingersResponse& obj) {obj.parsimPack(b);}
inline void doUnpacking(cCommBuffer *b, MyFixfingersResponse& obj) {obj.parsimUnpack(b);}

/**
 * Class generated from <tt>overlay/mychord/MyChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * packet MyFindGroupMemberMessage extends MyChordMessage
 * {
 * 	int finger;						
 * 	NodeHandle originalSrcNode;		
 * 	OverlayKey keyLimit;			
 * 	int groupId;					
 * 	int hopCount;					
 * }
 * </pre>
 */
class MyFindGroupMemberMessage : public ::MyChordMessage
{
  protected:
    int finger_var;
    ::NodeHandle originalSrcNode_var;
    ::OverlayKey keyLimit_var;
    int groupId_var;
    int hopCount_var;

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

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

    // field getter/setter methods
    virtual int getFinger() const;
    virtual void setFinger(int finger_var);
    virtual NodeHandle& getOriginalSrcNode();
    virtual const NodeHandle& getOriginalSrcNode() const {return const_cast<MyFindGroupMemberMessage*>(this)->getOriginalSrcNode();}
    virtual void setOriginalSrcNode(const NodeHandle& originalSrcNode_var);
    virtual OverlayKey& getKeyLimit();
    virtual const OverlayKey& getKeyLimit() const {return const_cast<MyFindGroupMemberMessage*>(this)->getKeyLimit();}
    virtual void setKeyLimit(const OverlayKey& keyLimit_var);
    virtual int getGroupId() const;
    virtual void setGroupId(int groupId_var);
    virtual int getHopCount() const;
    virtual void setHopCount(int hopCount_var);
};

inline void doPacking(cCommBuffer *b, MyFindGroupMemberMessage& obj) {obj.parsimPack(b);}
inline void doUnpacking(cCommBuffer *b, MyFindGroupMemberMessage& obj) {obj.parsimUnpack(b);}

/**
 * Class generated from <tt>overlay/mychord/MyChordMessage.msg</tt> by opp_msgc.
 * <pre>
 * packet MyFindGroupMemberReply extends MyChordMessage
 * {
 * 	int finger;						
 * 	NodeHandle sucNode[];				
 * 	int groupId;					
 * }
 * </pre>
 */
class MyFindGroupMemberReply : public ::MyChordMessage
{
  protected:
    int finger_var;
    ::NodeHandle *sucNode_var; // array ptr
    unsigned int sucNode_arraysize;
    int groupId_var;

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

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

    // field getter/setter methods
    virtual int getFinger() const;
    virtual void setFinger(int finger_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<MyFindGroupMemberReply*>(this)->getSucNode(k);}
    virtual void setSucNode(unsigned int k, const NodeHandle& sucNode_var);
    virtual int getGroupId() const;
    virtual void setGroupId(int groupId_var);
};

inline void doPacking(cCommBuffer *b, MyFindGroupMemberReply& obj) {obj.parsimPack(b);}
inline void doUnpacking(cCommBuffer *b, MyFindGroupMemberReply& obj) {obj.parsimUnpack(b);}


#endif // _MYCHORDMESSAGE_M_H_
