ChordMessage_m.h

Go to the documentation of this file.
00001 //
00002 // Generated file, do not edit! Created by opp_msgc 4.1 from overlay/chord/ChordMessage.msg.
00003 //
00004 
00005 #ifndef _CHORDMESSAGE_M_H_
00006 #define _CHORDMESSAGE_M_H_
00007 
00008 #include <omnetpp.h>
00009 
00010 // opp_msgc version check
00011 #define MSGC_VERSION 0x0401
00012 #if (MSGC_VERSION!=OMNETPP_VERSION)
00013 #    error Version mismatch! Probably this file was generated by an earlier version of opp_msgc: 'make clean' should help.
00014 #endif
00015 
00016 // cplusplus {{
00017 #include <IPvXAddress.h>
00018 #include <NodeHandle.h>
00019 #include <TransportAddress.h>
00020 #include <CommonMessages_m.h>
00021 
00022 
00023 static const int CHORDCOMMAND_L = 8;
00024 static const int SUCNUM_L = 8;
00025 static const int FINGER_L = 8;
00026 static const int STEP_L = 8;
00027 static const int PRENODESET_L = 1;
00028 
00029 #define NEWSUCCESSORHINT_L(msg) (BASEOVERLAY_L(msg) + CHORDCOMMAND_L + \
00030                                  2*NODEHANDLE_L)
00031 #define NOTIFYCALL_L(msg) (BASECALL_L(msg))
00032 #define NOTIFYRESPONSE_L(msg) (BASERESPONSE_L(msg) + SUCNUM_L + NODEHANDLE_L +\
00033                               (msg->getSucNodeArraySize() * NODEHANDLE_L) +\
00034                   PRENODESET_L)
00035 #define JOINCALL_L(msg) BASECALL_L(msg)
00036 #define JOINRESPONSE_L(msg) (BASERESPONSE_L(msg) + SUCNUM_L + NODEHANDLE_L +\
00037                              (msg->getSucNodeArraySize() * NODEHANDLE_L))
00038 #define STABILIZECALL_L(msg) BASECALL_L(msg)
00039 #define STABILIZERESPONSE_L(msg) (BASERESPONSE_L(msg) + NODEHANDLE_L)
00040 #define FIXFINGERSCALL_L(msg) (BASECALL_L(msg) + FINGER_L)
00041 #define FIXFINGERSRESPONSE_L(msg) (BASERESPONSE_L(msg) + FINGER_L + \
00042                                    NODEHANDLE_L + SUCNUM_L + \
00043                                    (msg->getSucNodeArraySize() * NODEHANDLE_L))
00044 #define DEBRUIJNCALL_L(msg) (BASECALL_L(msg) + KEY_L)
00045 #define DEBRUIJNRESPONSE_L(msg) (BASERESPONSE_L(msg) + SUCNUM_L + NODEHANDLE_L + \
00046                                  (msg->getSucNodeArraySize() * NODEHANDLE_L)) 
00047 
00048 #define KOORDEFINDNODEEXTMESSAGE_L (KEY_L + STEP_L)
00049 // }}
00050 
00051 
00052 
00063 enum ChordCommand {
00064     NEWSUCCESSORHINT = 0
00065 };
00066 
00076 class ChordMessage : public ::BaseOverlayMessage
00077 {
00078   protected:
00079     int command_var;
00080 
00081     // protected and unimplemented operator==(), to prevent accidental usage
00082     bool operator==(const ChordMessage&);
00083 
00084   public:
00085     ChordMessage(const char *name=NULL, int kind=0);
00086     ChordMessage(const ChordMessage& other);
00087     virtual ~ChordMessage();
00088     ChordMessage& operator=(const ChordMessage& other);
00089     virtual ChordMessage *dup() const {return new ChordMessage(*this);}
00090     virtual void parsimPack(cCommBuffer *b);
00091     virtual void parsimUnpack(cCommBuffer *b);
00092 
00093     // field getter/setter methods
00094     virtual int getCommand() const;
00095     virtual void setCommand(int command_var);
00096 };
00097 
00098 inline void doPacking(cCommBuffer *b, ChordMessage& obj) {obj.parsimPack(b);}
00099 inline void doUnpacking(cCommBuffer *b, ChordMessage& obj) {obj.parsimUnpack(b);}
00100 
00111 class NewSuccessorHintMessage : public ::ChordMessage
00112 {
00113   protected:
00114     ::NodeHandle srcNode_var;
00115     ::NodeHandle preNode_var;
00116 
00117     // protected and unimplemented operator==(), to prevent accidental usage
00118     bool operator==(const NewSuccessorHintMessage&);
00119 
00120   public:
00121     NewSuccessorHintMessage(const char *name=NULL, int kind=0);
00122     NewSuccessorHintMessage(const NewSuccessorHintMessage& other);
00123     virtual ~NewSuccessorHintMessage();
00124     NewSuccessorHintMessage& operator=(const NewSuccessorHintMessage& other);
00125     virtual NewSuccessorHintMessage *dup() const {return new NewSuccessorHintMessage(*this);}
00126     virtual void parsimPack(cCommBuffer *b);
00127     virtual void parsimUnpack(cCommBuffer *b);
00128 
00129     // field getter/setter methods
00130     virtual NodeHandle& getSrcNode();
00131     virtual const NodeHandle& getSrcNode() const {return const_cast<NewSuccessorHintMessage*>(this)->getSrcNode();}
00132     virtual void setSrcNode(const NodeHandle& srcNode_var);
00133     virtual NodeHandle& getPreNode();
00134     virtual const NodeHandle& getPreNode() const {return const_cast<NewSuccessorHintMessage*>(this)->getPreNode();}
00135     virtual void setPreNode(const NodeHandle& preNode_var);
00136 };
00137 
00138 inline void doPacking(cCommBuffer *b, NewSuccessorHintMessage& obj) {obj.parsimPack(b);}
00139 inline void doUnpacking(cCommBuffer *b, NewSuccessorHintMessage& obj) {obj.parsimUnpack(b);}
00140 
00150 class NotifyCall : public ::BaseCallMessage
00151 {
00152   protected:
00153     ::TransportAddress failed_var;
00154 
00155     // protected and unimplemented operator==(), to prevent accidental usage
00156     bool operator==(const NotifyCall&);
00157 
00158   public:
00159     NotifyCall(const char *name=NULL, int kind=0);
00160     NotifyCall(const NotifyCall& other);
00161     virtual ~NotifyCall();
00162     NotifyCall& operator=(const NotifyCall& other);
00163     virtual NotifyCall *dup() const {return new NotifyCall(*this);}
00164     virtual void parsimPack(cCommBuffer *b);
00165     virtual void parsimUnpack(cCommBuffer *b);
00166 
00167     // field getter/setter methods
00168     virtual TransportAddress& getFailed();
00169     virtual const TransportAddress& getFailed() const {return const_cast<NotifyCall*>(this)->getFailed();}
00170     virtual void setFailed(const TransportAddress& failed_var);
00171 };
00172 
00173 inline void doPacking(cCommBuffer *b, NotifyCall& obj) {obj.parsimPack(b);}
00174 inline void doUnpacking(cCommBuffer *b, NotifyCall& obj) {obj.parsimUnpack(b);}
00175 
00188 class NotifyResponse : public ::BaseResponseMessage
00189 {
00190   protected:
00191     int sucNum_var;
00192     ::NodeHandle *sucNode_var; // array ptr
00193     unsigned int sucNode_arraysize;
00194     ::NodeHandle preNode_var;
00195     bool preNodeSet_var;
00196 
00197     // protected and unimplemented operator==(), to prevent accidental usage
00198     bool operator==(const NotifyResponse&);
00199 
00200   public:
00201     NotifyResponse(const char *name=NULL, int kind=0);
00202     NotifyResponse(const NotifyResponse& other);
00203     virtual ~NotifyResponse();
00204     NotifyResponse& operator=(const NotifyResponse& other);
00205     virtual NotifyResponse *dup() const {return new NotifyResponse(*this);}
00206     virtual void parsimPack(cCommBuffer *b);
00207     virtual void parsimUnpack(cCommBuffer *b);
00208 
00209     // field getter/setter methods
00210     virtual int getSucNum() const;
00211     virtual void setSucNum(int sucNum_var);
00212     virtual void setSucNodeArraySize(unsigned int size);
00213     virtual unsigned int getSucNodeArraySize() const;
00214     virtual NodeHandle& getSucNode(unsigned int k);
00215     virtual const NodeHandle& getSucNode(unsigned int k) const {return const_cast<NotifyResponse*>(this)->getSucNode(k);}
00216     virtual void setSucNode(unsigned int k, const NodeHandle& sucNode_var);
00217     virtual NodeHandle& getPreNode();
00218     virtual const NodeHandle& getPreNode() const {return const_cast<NotifyResponse*>(this)->getPreNode();}
00219     virtual void setPreNode(const NodeHandle& preNode_var);
00220     virtual bool getPreNodeSet() const;
00221     virtual void setPreNodeSet(bool preNodeSet_var);
00222 };
00223 
00224 inline void doPacking(cCommBuffer *b, NotifyResponse& obj) {obj.parsimPack(b);}
00225 inline void doUnpacking(cCommBuffer *b, NotifyResponse& obj) {obj.parsimUnpack(b);}
00226 
00235 class JoinCall : public ::BaseCallMessage
00236 {
00237   protected:
00238 
00239     // protected and unimplemented operator==(), to prevent accidental usage
00240     bool operator==(const JoinCall&);
00241 
00242   public:
00243     JoinCall(const char *name=NULL, int kind=0);
00244     JoinCall(const JoinCall& other);
00245     virtual ~JoinCall();
00246     JoinCall& operator=(const JoinCall& other);
00247     virtual JoinCall *dup() const {return new JoinCall(*this);}
00248     virtual void parsimPack(cCommBuffer *b);
00249     virtual void parsimUnpack(cCommBuffer *b);
00250 
00251     // field getter/setter methods
00252 };
00253 
00254 inline void doPacking(cCommBuffer *b, JoinCall& obj) {obj.parsimPack(b);}
00255 inline void doUnpacking(cCommBuffer *b, JoinCall& obj) {obj.parsimUnpack(b);}
00256 
00268 class JoinResponse : public ::BaseResponseMessage
00269 {
00270   protected:
00271     int sucNum_var;
00272     ::NodeHandle *sucNode_var; // array ptr
00273     unsigned int sucNode_arraysize;
00274     ::NodeHandle preNode_var;
00275 
00276     // protected and unimplemented operator==(), to prevent accidental usage
00277     bool operator==(const JoinResponse&);
00278 
00279   public:
00280     JoinResponse(const char *name=NULL, int kind=0);
00281     JoinResponse(const JoinResponse& other);
00282     virtual ~JoinResponse();
00283     JoinResponse& operator=(const JoinResponse& other);
00284     virtual JoinResponse *dup() const {return new JoinResponse(*this);}
00285     virtual void parsimPack(cCommBuffer *b);
00286     virtual void parsimUnpack(cCommBuffer *b);
00287 
00288     // field getter/setter methods
00289     virtual int getSucNum() const;
00290     virtual void setSucNum(int sucNum_var);
00291     virtual void setSucNodeArraySize(unsigned int size);
00292     virtual unsigned int getSucNodeArraySize() const;
00293     virtual NodeHandle& getSucNode(unsigned int k);
00294     virtual const NodeHandle& getSucNode(unsigned int k) const {return const_cast<JoinResponse*>(this)->getSucNode(k);}
00295     virtual void setSucNode(unsigned int k, const NodeHandle& sucNode_var);
00296     virtual NodeHandle& getPreNode();
00297     virtual const NodeHandle& getPreNode() const {return const_cast<JoinResponse*>(this)->getPreNode();}
00298     virtual void setPreNode(const NodeHandle& preNode_var);
00299 };
00300 
00301 inline void doPacking(cCommBuffer *b, JoinResponse& obj) {obj.parsimPack(b);}
00302 inline void doUnpacking(cCommBuffer *b, JoinResponse& obj) {obj.parsimUnpack(b);}
00303 
00312 class StabilizeCall : public ::BaseCallMessage
00313 {
00314   protected:
00315 
00316     // protected and unimplemented operator==(), to prevent accidental usage
00317     bool operator==(const StabilizeCall&);
00318 
00319   public:
00320     StabilizeCall(const char *name=NULL, int kind=0);
00321     StabilizeCall(const StabilizeCall& other);
00322     virtual ~StabilizeCall();
00323     StabilizeCall& operator=(const StabilizeCall& other);
00324     virtual StabilizeCall *dup() const {return new StabilizeCall(*this);}
00325     virtual void parsimPack(cCommBuffer *b);
00326     virtual void parsimUnpack(cCommBuffer *b);
00327 
00328     // field getter/setter methods
00329 };
00330 
00331 inline void doPacking(cCommBuffer *b, StabilizeCall& obj) {obj.parsimPack(b);}
00332 inline void doUnpacking(cCommBuffer *b, StabilizeCall& obj) {obj.parsimUnpack(b);}
00333 
00343 class StabilizeResponse : public ::BaseResponseMessage
00344 {
00345   protected:
00346     ::NodeHandle preNode_var;
00347 
00348     // protected and unimplemented operator==(), to prevent accidental usage
00349     bool operator==(const StabilizeResponse&);
00350 
00351   public:
00352     StabilizeResponse(const char *name=NULL, int kind=0);
00353     StabilizeResponse(const StabilizeResponse& other);
00354     virtual ~StabilizeResponse();
00355     StabilizeResponse& operator=(const StabilizeResponse& other);
00356     virtual StabilizeResponse *dup() const {return new StabilizeResponse(*this);}
00357     virtual void parsimPack(cCommBuffer *b);
00358     virtual void parsimUnpack(cCommBuffer *b);
00359 
00360     // field getter/setter methods
00361     virtual NodeHandle& getPreNode();
00362     virtual const NodeHandle& getPreNode() const {return const_cast<StabilizeResponse*>(this)->getPreNode();}
00363     virtual void setPreNode(const NodeHandle& preNode_var);
00364 };
00365 
00366 inline void doPacking(cCommBuffer *b, StabilizeResponse& obj) {obj.parsimPack(b);}
00367 inline void doUnpacking(cCommBuffer *b, StabilizeResponse& obj) {obj.parsimUnpack(b);}
00368 
00378 class FixfingersCall : public ::BaseCallMessage
00379 {
00380   protected:
00381     int finger_var;
00382 
00383     // protected and unimplemented operator==(), to prevent accidental usage
00384     bool operator==(const FixfingersCall&);
00385 
00386   public:
00387     FixfingersCall(const char *name=NULL, int kind=0);
00388     FixfingersCall(const FixfingersCall& other);
00389     virtual ~FixfingersCall();
00390     FixfingersCall& operator=(const FixfingersCall& other);
00391     virtual FixfingersCall *dup() const {return new FixfingersCall(*this);}
00392     virtual void parsimPack(cCommBuffer *b);
00393     virtual void parsimUnpack(cCommBuffer *b);
00394 
00395     // field getter/setter methods
00396     virtual int getFinger() const;
00397     virtual void setFinger(int finger_var);
00398 };
00399 
00400 inline void doPacking(cCommBuffer *b, FixfingersCall& obj) {obj.parsimPack(b);}
00401 inline void doUnpacking(cCommBuffer *b, FixfingersCall& obj) {obj.parsimUnpack(b);}
00402 
00413 class FixfingersResponse : public ::BaseResponseMessage
00414 {
00415   protected:
00416     int finger_var;
00417     ::NodeHandle *sucNode_var; // array ptr
00418     unsigned int sucNode_arraysize;
00419 
00420     // protected and unimplemented operator==(), to prevent accidental usage
00421     bool operator==(const FixfingersResponse&);
00422 
00423   public:
00424     FixfingersResponse(const char *name=NULL, int kind=0);
00425     FixfingersResponse(const FixfingersResponse& other);
00426     virtual ~FixfingersResponse();
00427     FixfingersResponse& operator=(const FixfingersResponse& other);
00428     virtual FixfingersResponse *dup() const {return new FixfingersResponse(*this);}
00429     virtual void parsimPack(cCommBuffer *b);
00430     virtual void parsimUnpack(cCommBuffer *b);
00431 
00432     // field getter/setter methods
00433     virtual int getFinger() const;
00434     virtual void setFinger(int finger_var);
00435     virtual void setSucNodeArraySize(unsigned int size);
00436     virtual unsigned int getSucNodeArraySize() const;
00437     virtual NodeHandle& getSucNode(unsigned int k);
00438     virtual const NodeHandle& getSucNode(unsigned int k) const {return const_cast<FixfingersResponse*>(this)->getSucNode(k);}
00439     virtual void setSucNode(unsigned int k, const NodeHandle& sucNode_var);
00440 };
00441 
00442 inline void doPacking(cCommBuffer *b, FixfingersResponse& obj) {obj.parsimPack(b);}
00443 inline void doUnpacking(cCommBuffer *b, FixfingersResponse& obj) {obj.parsimUnpack(b);}
00444 
00455 class KoordeFindNodeExtMessage : public ::cPacket
00456 {
00457   protected:
00458     ::OverlayKey routeKey_var;
00459     int step_var;
00460 
00461     // protected and unimplemented operator==(), to prevent accidental usage
00462     bool operator==(const KoordeFindNodeExtMessage&);
00463 
00464   public:
00465     KoordeFindNodeExtMessage(const char *name=NULL, int kind=0);
00466     KoordeFindNodeExtMessage(const KoordeFindNodeExtMessage& other);
00467     virtual ~KoordeFindNodeExtMessage();
00468     KoordeFindNodeExtMessage& operator=(const KoordeFindNodeExtMessage& other);
00469     virtual KoordeFindNodeExtMessage *dup() const {return new KoordeFindNodeExtMessage(*this);}
00470     virtual void parsimPack(cCommBuffer *b);
00471     virtual void parsimUnpack(cCommBuffer *b);
00472 
00473     // field getter/setter methods
00474     virtual OverlayKey& getRouteKey();
00475     virtual const OverlayKey& getRouteKey() const {return const_cast<KoordeFindNodeExtMessage*>(this)->getRouteKey();}
00476     virtual void setRouteKey(const OverlayKey& routeKey_var);
00477     virtual int getStep() const;
00478     virtual void setStep(int step_var);
00479 };
00480 
00481 inline void doPacking(cCommBuffer *b, KoordeFindNodeExtMessage& obj) {obj.parsimPack(b);}
00482 inline void doUnpacking(cCommBuffer *b, KoordeFindNodeExtMessage& obj) {obj.parsimUnpack(b);}
00483 
00493 class DeBruijnCall : public ::BaseCallMessage
00494 {
00495   protected:
00496     ::OverlayKey destKey_var;
00497 
00498     // protected and unimplemented operator==(), to prevent accidental usage
00499     bool operator==(const DeBruijnCall&);
00500 
00501   public:
00502     DeBruijnCall(const char *name=NULL, int kind=0);
00503     DeBruijnCall(const DeBruijnCall& other);
00504     virtual ~DeBruijnCall();
00505     DeBruijnCall& operator=(const DeBruijnCall& other);
00506     virtual DeBruijnCall *dup() const {return new DeBruijnCall(*this);}
00507     virtual void parsimPack(cCommBuffer *b);
00508     virtual void parsimUnpack(cCommBuffer *b);
00509 
00510     // field getter/setter methods
00511     virtual OverlayKey& getDestKey();
00512     virtual const OverlayKey& getDestKey() const {return const_cast<DeBruijnCall*>(this)->getDestKey();}
00513     virtual void setDestKey(const OverlayKey& destKey_var);
00514 };
00515 
00516 inline void doPacking(cCommBuffer *b, DeBruijnCall& obj) {obj.parsimPack(b);}
00517 inline void doUnpacking(cCommBuffer *b, DeBruijnCall& obj) {obj.parsimUnpack(b);}
00518 
00530 class DeBruijnResponse : public ::BaseResponseMessage
00531 {
00532   protected:
00533     ::NodeHandle dBNode_var;
00534     int sucNum_var;
00535     ::NodeHandle *sucNode_var; // array ptr
00536     unsigned int sucNode_arraysize;
00537 
00538     // protected and unimplemented operator==(), to prevent accidental usage
00539     bool operator==(const DeBruijnResponse&);
00540 
00541   public:
00542     DeBruijnResponse(const char *name=NULL, int kind=0);
00543     DeBruijnResponse(const DeBruijnResponse& other);
00544     virtual ~DeBruijnResponse();
00545     DeBruijnResponse& operator=(const DeBruijnResponse& other);
00546     virtual DeBruijnResponse *dup() const {return new DeBruijnResponse(*this);}
00547     virtual void parsimPack(cCommBuffer *b);
00548     virtual void parsimUnpack(cCommBuffer *b);
00549 
00550     // field getter/setter methods
00551     virtual NodeHandle& getDBNode();
00552     virtual const NodeHandle& getDBNode() const {return const_cast<DeBruijnResponse*>(this)->getDBNode();}
00553     virtual void setDBNode(const NodeHandle& dBNode_var);
00554     virtual int getSucNum() const;
00555     virtual void setSucNum(int sucNum_var);
00556     virtual void setSucNodeArraySize(unsigned int size);
00557     virtual unsigned int getSucNodeArraySize() const;
00558     virtual NodeHandle& getSucNode(unsigned int k);
00559     virtual const NodeHandle& getSucNode(unsigned int k) const {return const_cast<DeBruijnResponse*>(this)->getSucNode(k);}
00560     virtual void setSucNode(unsigned int k, const NodeHandle& sucNode_var);
00561 };
00562 
00563 inline void doPacking(cCommBuffer *b, DeBruijnResponse& obj) {obj.parsimPack(b);}
00564 inline void doUnpacking(cCommBuffer *b, DeBruijnResponse& obj) {obj.parsimUnpack(b);}
00565 
00566 
00567 #endif // _CHORDMESSAGE_M_H_