CommonMessages_m.h

Go to the documentation of this file.
00001 //
00002 // Generated file, do not edit! Created by opp_msgc 4.0 from common/CommonMessages.msg.
00003 //
00004 
00005 #ifndef _COMMONMESSAGES_M_H_
00006 #define _COMMONMESSAGES_M_H_
00007 
00008 #include <omnetpp.h>
00009 
00010 // opp_msgc version check
00011 #define MSGC_VERSION 0x0400
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 {{ ... }} section:
00017 
00018 #include <OverlayKey.h>
00019 #include <NodeHandle.h>
00020 #include <IPvXAddress.h>
00021 #include <TransportAddress.h>
00022 #include <BinaryValue.h>
00023 #include <Vector2D.h>
00024 #include <OverSimMessage.h>
00025 
00026 #define KEY_L OverlayKey::getLength()
00027 
00028 static const int TYPE_L = 8;
00029 static const int IPADDR_L = 32;
00030 static const int UDPPORT_L = 16;
00031 static const int HOPCOUNT_L = 16;
00032 static const int NONCE_L = 32;
00033 static const int COMP_L = 16;
00034 static const int NUMSIBLINGS_L = 8;
00035 static const int NUMREDNODES_L = 8;
00036 static const int EXHAUSTIVEFLAG_L = 8;
00037 static const int NEIGHBORSFLAG_L = 8;
00038 static const int RESPONSEFLAG_L = 8;
00039 static const int TRYAGAINFLAG_L = 8;
00040 static const int TIER_L = 8;
00041 static const int ARRAYSIZE_L = 8;
00042 static const int ROUTINGTYPE_L = 8;
00043 
00044 #define NODEHANDLE_L (IPADDR_L + UDPPORT_L + KEY_L)
00045 
00046 
00047 #define TRANSPORTADDRESS_L (IPADDR_L + UDPPORT_L)
00048 
00049 #define BASEOVERLAY_L(msg) TYPE_L
00050 #define BASEROUTE_L(msg) (BASEOVERLAY_L(msg) + NODEHANDLE_L + KEY_L + \
00051                           HOPCOUNT_L + ROUTINGTYPE_L +\
00052                           ARRAYSIZE_L + (msg->getVisitedHopsArraySize() *\
00053                           TRANSPORTADDRESS_L) +\
00054                           ARRAYSIZE_L + (msg->getNextHopsArraySize() *\
00055                           TRANSPORTADDRESS_L) +\
00056                           ARRAYSIZE_L + (msg->getHintsArraySize() *\
00057                           NODEHANDLE_L))
00058 #define BASEAPPDATA_L(msg) (BASEOVERLAY_L(msg) + 2*COMP_L)
00059 #define BASERPC_L(msg) (BASEOVERLAY_L(msg) + NONCE_L + NODEHANDLE_L + \
00060                         TIER_L)
00061 #define BASECALL_L(msg) BASERPC_L(msg)
00062 #define BASERESPONSE_L(msg) BASERPC_L(msg)
00063 #define FINDNODECALL_L(msg) (BASECALL_L(msg) + KEY_L + NUMSIBLINGS_L + \
00064                              NUMREDNODES_L + EXHAUSTIVEFLAG_L)
00065 
00066 #define FINDNODERESPONSE_L(msg) (BASERESPONSE_L(msg) + NEIGHBORSFLAG_L + \
00067                   (msg->getClosestNodesArraySize() * NODEHANDLE_L))
00068 #define FAILEDNODECALL_L(msg) (BASECALL_L(msg) + IPADDR_L + UDPPORT_L)
00069 #define FAILEDNODERESPONSE_L(msg) (BASERESPONSE_L(msg) + TRYAGAINFLAG_L)
00070 #define PINGCALL_L(msg) BASECALL_L(msg)
00071 #define PINGRESPONSE_L(msg) BASERESPONSE_L(msg)
00072 #define BOOTSTRAPPINGCALL_L(msg) BASECALL_L(msg)
00073 #define BOOTSTRAPPINGRESPONSE_L(msg) BASERESPONSE_L(msg)
00074 #define NEXTHOPCALL_L(msg) BASECALL_L(msg)
00075 #define NEXTHOPRESPONSE_L(msg) BASERESPONSE_L(msg)
00076 // end cplusplus
00077 
00078 
00079 
00093 enum BaseOverlayMessageType {
00094     OVERLAYSIGNALING = 0,
00095     RPC = 1,
00096     APPDATA = 2,
00097     OVERLAYROUTE = 3
00098 };
00099 
00116 enum CompType {
00117     INVALID_COMP = 0,
00118     OVERLAY_COMP = 1,
00119     TIER1_COMP = 2,
00120     TIER2_COMP = 3,
00121     TIER3_COMP = 4,
00122     BOOTSTRAPLIST_COMP = 5,
00123     NEIGHBORCACHE_COMP = 6
00124 };
00125 
00142 enum RoutingType {
00143     NO_OVERLAY_ROUTING = 0,
00144     DEFAULT_ROUTING = 1,
00145     ITERATIVE_ROUTING = 2,
00146     EXHAUSTIVE_ITERATIVE_ROUTING = 3,
00147     SEMI_RECURSIVE_ROUTING = 4,
00148     FULL_RECURSIVE_ROUTING = 5,
00149     RECURSIVE_SOURCE_ROUTING = 6
00150 };
00151 
00165 enum TransportType {
00166     INVALID_TRANSPORT = 0,
00167     INTERNAL_TRANSPORT = 1,
00168     UDP_TRANSPORT = 2,
00169     ROUTE_TRANSPORT = 3
00170 };
00171 
00187 enum CommonAPIMessageType {
00188     COMMON_API_UNDEFINED = 0,
00189     KBR_ROUTE = 1,
00190     KBR_DELIVER = 2,
00191     KBR_FORWARD = 3,
00192     KBR_FORWARD_RESPONSE = 4,
00193     KBR_UPDATE = 5
00194 };
00195 
00209 enum StatType {
00210     MAINTENANCE_STAT = 0,
00211     APP_DATA_STAT = 1,
00212     APP_LOOKUP_STAT = 2
00213 };
00214 
00231 enum GameAPIMessageCommand {
00232     MOVEMENT_INDICATION = 0,
00233     MOVEMENT_REQUEST = 1,
00234     NEIGHBOR_UPDATE = 2,
00235     RESIZE_AOI = 3,
00236     GAMEEVENT_CHAT = 4,
00237     GAMEEVENT_SNOW = 5,
00238     GAMEEVENT_FROZEN = 6
00239 };
00240 
00252 class AuthBlock : public cObject
00253 {
00254   protected:
00255     BinaryValue signature_var;
00256     BinaryValue pubKey_var;
00257     BinaryValue cert_var;
00258 
00259     // protected and unimplemented operator==(), to prevent accidental usage
00260     bool operator==(const AuthBlock&);
00261 
00262   public:
00263     AuthBlock();
00264     AuthBlock(const AuthBlock& other);
00265     virtual ~AuthBlock();
00266     AuthBlock& operator=(const AuthBlock& other);
00267     virtual AuthBlock *dup() const {return new AuthBlock(*this);}
00268     virtual void parsimPack(cCommBuffer *b);
00269     virtual void parsimUnpack(cCommBuffer *b);
00270 
00271     // field getter/setter methods
00272     virtual BinaryValue& getSignature();
00273     virtual const BinaryValue& getSignature() const {return const_cast<AuthBlock*>(this)->getSignature();}
00274     virtual void setSignature(const BinaryValue& signature_var);
00275     virtual BinaryValue& getPubKey();
00276     virtual const BinaryValue& getPubKey() const {return const_cast<AuthBlock*>(this)->getPubKey();}
00277     virtual void setPubKey(const BinaryValue& pubKey_var);
00278     virtual BinaryValue& getCert();
00279     virtual const BinaryValue& getCert() const {return const_cast<AuthBlock*>(this)->getCert();}
00280     virtual void setCert(const BinaryValue& cert_var);
00281 };
00282 
00283 inline void doPacking(cCommBuffer *b, AuthBlock& obj) {obj.parsimPack(b);}
00284 inline void doUnpacking(cCommBuffer *b, AuthBlock& obj) {obj.parsimUnpack(b);}
00285 
00296 class BaseOverlayMessage : public OverSimMessage
00297 {
00298   protected:
00299     int type_var;
00300     int statType_var;
00301 
00302     // protected and unimplemented operator==(), to prevent accidental usage
00303     bool operator==(const BaseOverlayMessage&);
00304 
00305   public:
00306     BaseOverlayMessage(const char *name=NULL, int kind=0);
00307     BaseOverlayMessage(const BaseOverlayMessage& other);
00308     virtual ~BaseOverlayMessage();
00309     BaseOverlayMessage& operator=(const BaseOverlayMessage& other);
00310     virtual BaseOverlayMessage *dup() const {return new BaseOverlayMessage(*this);}
00311     virtual void parsimPack(cCommBuffer *b);
00312     virtual void parsimUnpack(cCommBuffer *b);
00313 
00314     // field getter/setter methods
00315     virtual int getType() const;
00316     virtual void setType(int type_var);
00317     virtual int getStatType() const;
00318     virtual void setStatType(int statType_var);
00319 };
00320 
00321 inline void doPacking(cCommBuffer *b, BaseOverlayMessage& obj) {obj.parsimPack(b);}
00322 inline void doUnpacking(cCommBuffer *b, BaseOverlayMessage& obj) {obj.parsimUnpack(b);}
00323 
00341 class BaseRouteMessage : public BaseOverlayMessage
00342 {
00343   protected:
00344     OverlayKey destKey_var;
00345     NodeHandle srcNode_var;
00346     int routingType_var;
00347     int hopCount_var;
00348     TransportAddress *visitedHops_var; // array ptr
00349     unsigned int visitedHops_arraysize;
00350     TransportAddress *nextHops_var; // array ptr
00351     unsigned int nextHops_arraysize;
00352     NodeHandle *hints_var; // array ptr
00353     unsigned int hints_arraysize;
00354     simtime_t hopStamp_var;
00355     simtime_t *hopDelay_var; // array ptr
00356     unsigned int hopDelay_arraysize;
00357 
00358     // protected and unimplemented operator==(), to prevent accidental usage
00359     bool operator==(const BaseRouteMessage&);
00360 
00361   public:
00362     BaseRouteMessage(const char *name=NULL, int kind=0);
00363     BaseRouteMessage(const BaseRouteMessage& other);
00364     virtual ~BaseRouteMessage();
00365     BaseRouteMessage& operator=(const BaseRouteMessage& other);
00366     virtual BaseRouteMessage *dup() const {return new BaseRouteMessage(*this);}
00367     virtual void parsimPack(cCommBuffer *b);
00368     virtual void parsimUnpack(cCommBuffer *b);
00369 
00370     // field getter/setter methods
00371     virtual OverlayKey& getDestKey();
00372     virtual const OverlayKey& getDestKey() const {return const_cast<BaseRouteMessage*>(this)->getDestKey();}
00373     virtual void setDestKey(const OverlayKey& destKey_var);
00374     virtual NodeHandle& getSrcNode();
00375     virtual const NodeHandle& getSrcNode() const {return const_cast<BaseRouteMessage*>(this)->getSrcNode();}
00376     virtual void setSrcNode(const NodeHandle& srcNode_var);
00377     virtual int getRoutingType() const;
00378     virtual void setRoutingType(int routingType_var);
00379     virtual int getHopCount() const;
00380     virtual void setHopCount(int hopCount_var);
00381     virtual void setVisitedHopsArraySize(unsigned int size);
00382     virtual unsigned int getVisitedHopsArraySize() const;
00383     virtual TransportAddress& getVisitedHops(unsigned int k);
00384     virtual const TransportAddress& getVisitedHops(unsigned int k) const {return const_cast<BaseRouteMessage*>(this)->getVisitedHops(k);}
00385     virtual void setVisitedHops(unsigned int k, const TransportAddress& visitedHops_var);
00386     virtual void setNextHopsArraySize(unsigned int size);
00387     virtual unsigned int getNextHopsArraySize() const;
00388     virtual TransportAddress& getNextHops(unsigned int k);
00389     virtual const TransportAddress& getNextHops(unsigned int k) const {return const_cast<BaseRouteMessage*>(this)->getNextHops(k);}
00390     virtual void setNextHops(unsigned int k, const TransportAddress& nextHops_var);
00391     virtual void setHintsArraySize(unsigned int size);
00392     virtual unsigned int getHintsArraySize() const;
00393     virtual NodeHandle& getHints(unsigned int k);
00394     virtual const NodeHandle& getHints(unsigned int k) const {return const_cast<BaseRouteMessage*>(this)->getHints(k);}
00395     virtual void setHints(unsigned int k, const NodeHandle& hints_var);
00396     virtual simtime_t getHopStamp() const;
00397     virtual void setHopStamp(simtime_t hopStamp_var);
00398     virtual void setHopDelayArraySize(unsigned int size);
00399     virtual unsigned int getHopDelayArraySize() const;
00400     virtual simtime_t getHopDelay(unsigned int k) const;
00401     virtual void setHopDelay(unsigned int k, simtime_t hopDelay_var);
00402 };
00403 
00404 inline void doPacking(cCommBuffer *b, BaseRouteMessage& obj) {obj.parsimPack(b);}
00405 inline void doUnpacking(cCommBuffer *b, BaseRouteMessage& obj) {obj.parsimUnpack(b);}
00406 
00417 class BaseAppDataMessage : public BaseOverlayMessage
00418 {
00419   protected:
00420     int destComp_var;
00421     int srcComp_var;
00422 
00423     // protected and unimplemented operator==(), to prevent accidental usage
00424     bool operator==(const BaseAppDataMessage&);
00425 
00426   public:
00427     BaseAppDataMessage(const char *name=NULL, int kind=0);
00428     BaseAppDataMessage(const BaseAppDataMessage& other);
00429     virtual ~BaseAppDataMessage();
00430     BaseAppDataMessage& operator=(const BaseAppDataMessage& other);
00431     virtual BaseAppDataMessage *dup() const {return new BaseAppDataMessage(*this);}
00432     virtual void parsimPack(cCommBuffer *b);
00433     virtual void parsimUnpack(cCommBuffer *b);
00434 
00435     // field getter/setter methods
00436     virtual int getDestComp() const;
00437     virtual void setDestComp(int destComp_var);
00438     virtual int getSrcComp() const;
00439     virtual void setSrcComp(int srcComp_var);
00440 };
00441 
00442 inline void doPacking(cCommBuffer *b, BaseAppDataMessage& obj) {obj.parsimPack(b);}
00443 inline void doUnpacking(cCommBuffer *b, BaseAppDataMessage& obj) {obj.parsimUnpack(b);}
00444 
00456 class BaseRpcMessage : public BaseOverlayMessage
00457 {
00458   protected:
00459     unsigned int nonce_var;
00460     NodeHandle srcNode_var;
00461     AuthBlock *authBlock_var; // array ptr
00462     uint8_t authBlock_arraysize;
00463 
00464     // protected and unimplemented operator==(), to prevent accidental usage
00465     bool operator==(const BaseRpcMessage&);
00466 
00467   public:
00468     BaseRpcMessage(const char *name=NULL, int kind=0);
00469     BaseRpcMessage(const BaseRpcMessage& other);
00470     virtual ~BaseRpcMessage();
00471     BaseRpcMessage& operator=(const BaseRpcMessage& other);
00472     virtual BaseRpcMessage *dup() const {return new BaseRpcMessage(*this);}
00473     virtual void parsimPack(cCommBuffer *b);
00474     virtual void parsimUnpack(cCommBuffer *b);
00475 
00476     // field getter/setter methods
00477     virtual unsigned int getNonce() const;
00478     virtual void setNonce(unsigned int nonce_var);
00479     virtual NodeHandle& getSrcNode();
00480     virtual const NodeHandle& getSrcNode() const {return const_cast<BaseRpcMessage*>(this)->getSrcNode();}
00481     virtual void setSrcNode(const NodeHandle& srcNode_var);
00482     virtual void setAuthBlockArraySize(unsigned int size);
00483     virtual unsigned int getAuthBlockArraySize() const;
00484     virtual AuthBlock& getAuthBlock(unsigned int k);
00485     virtual const AuthBlock& getAuthBlock(unsigned int k) const {return const_cast<BaseRpcMessage*>(this)->getAuthBlock(k);}
00486     virtual void setAuthBlock(unsigned int k, const AuthBlock& authBlock_var);
00487 };
00488 
00489 inline void doPacking(cCommBuffer *b, BaseRpcMessage& obj) {obj.parsimPack(b);}
00490 inline void doUnpacking(cCommBuffer *b, BaseRpcMessage& obj) {obj.parsimUnpack(b);}
00491 
00500 class BaseCallMessage : public BaseRpcMessage
00501 {
00502   protected:
00503 
00504     // protected and unimplemented operator==(), to prevent accidental usage
00505     bool operator==(const BaseCallMessage&);
00506 
00507   public:
00508     BaseCallMessage(const char *name=NULL, int kind=0);
00509     BaseCallMessage(const BaseCallMessage& other);
00510     virtual ~BaseCallMessage();
00511     BaseCallMessage& operator=(const BaseCallMessage& other);
00512     virtual BaseCallMessage *dup() const {return new BaseCallMessage(*this);}
00513     virtual void parsimPack(cCommBuffer *b);
00514     virtual void parsimUnpack(cCommBuffer *b);
00515 
00516     // field getter/setter methods
00517 };
00518 
00519 inline void doPacking(cCommBuffer *b, BaseCallMessage& obj) {obj.parsimPack(b);}
00520 inline void doUnpacking(cCommBuffer *b, BaseCallMessage& obj) {obj.parsimUnpack(b);}
00521 
00533 class BaseResponseMessage : public BaseRpcMessage
00534 {
00535   protected:
00536     int callHopCount_var;
00537     double *coords_var; // array ptr
00538     unsigned int coords_arraysize;
00539     double error_var;
00540 
00541     // protected and unimplemented operator==(), to prevent accidental usage
00542     bool operator==(const BaseResponseMessage&);
00543 
00544   public:
00545     BaseResponseMessage(const char *name=NULL, int kind=0);
00546     BaseResponseMessage(const BaseResponseMessage& other);
00547     virtual ~BaseResponseMessage();
00548     BaseResponseMessage& operator=(const BaseResponseMessage& other);
00549     virtual BaseResponseMessage *dup() const {return new BaseResponseMessage(*this);}
00550     virtual void parsimPack(cCommBuffer *b);
00551     virtual void parsimUnpack(cCommBuffer *b);
00552 
00553     // field getter/setter methods
00554     virtual int getCallHopCount() const;
00555     virtual void setCallHopCount(int callHopCount_var);
00556     virtual void setCoordsArraySize(unsigned int size);
00557     virtual unsigned int getCoordsArraySize() const;
00558     virtual double getCoords(unsigned int k) const;
00559     virtual void setCoords(unsigned int k, double coords_var);
00560     virtual double getError() const;
00561     virtual void setError(double error_var);
00562 };
00563 
00564 inline void doPacking(cCommBuffer *b, BaseResponseMessage& obj) {obj.parsimPack(b);}
00565 inline void doUnpacking(cCommBuffer *b, BaseResponseMessage& obj) {obj.parsimUnpack(b);}
00566 
00575 class RpcTimeoutMessage : public BaseRpcMessage
00576 {
00577   protected:
00578 
00579     // protected and unimplemented operator==(), to prevent accidental usage
00580     bool operator==(const RpcTimeoutMessage&);
00581 
00582   public:
00583     RpcTimeoutMessage(const char *name=NULL, int kind=0);
00584     RpcTimeoutMessage(const RpcTimeoutMessage& other);
00585     virtual ~RpcTimeoutMessage();
00586     RpcTimeoutMessage& operator=(const RpcTimeoutMessage& other);
00587     virtual RpcTimeoutMessage *dup() const {return new RpcTimeoutMessage(*this);}
00588     virtual void parsimPack(cCommBuffer *b);
00589     virtual void parsimUnpack(cCommBuffer *b);
00590 
00591     // field getter/setter methods
00592 };
00593 
00594 inline void doPacking(cCommBuffer *b, RpcTimeoutMessage& obj) {obj.parsimPack(b);}
00595 inline void doUnpacking(cCommBuffer *b, RpcTimeoutMessage& obj) {obj.parsimUnpack(b);}
00596 
00609 class FindNodeCall : public BaseCallMessage
00610 {
00611   protected:
00612     OverlayKey lookupKey_var;
00613     int numRedundantNodes_var;
00614     int numSiblings_var;
00615     bool exhaustiveIterative_var;
00616 
00617     // protected and unimplemented operator==(), to prevent accidental usage
00618     bool operator==(const FindNodeCall&);
00619 
00620   public:
00621     FindNodeCall(const char *name=NULL, int kind=0);
00622     FindNodeCall(const FindNodeCall& other);
00623     virtual ~FindNodeCall();
00624     FindNodeCall& operator=(const FindNodeCall& other);
00625     virtual FindNodeCall *dup() const {return new FindNodeCall(*this);}
00626     virtual void parsimPack(cCommBuffer *b);
00627     virtual void parsimUnpack(cCommBuffer *b);
00628 
00629     // field getter/setter methods
00630     virtual OverlayKey& getLookupKey();
00631     virtual const OverlayKey& getLookupKey() const {return const_cast<FindNodeCall*>(this)->getLookupKey();}
00632     virtual void setLookupKey(const OverlayKey& lookupKey_var);
00633     virtual int getNumRedundantNodes() const;
00634     virtual void setNumRedundantNodes(int numRedundantNodes_var);
00635     virtual int getNumSiblings() const;
00636     virtual void setNumSiblings(int numSiblings_var);
00637     virtual bool getExhaustiveIterative() const;
00638     virtual void setExhaustiveIterative(bool exhaustiveIterative_var);
00639 };
00640 
00641 inline void doPacking(cCommBuffer *b, FindNodeCall& obj) {obj.parsimPack(b);}
00642 inline void doUnpacking(cCommBuffer *b, FindNodeCall& obj) {obj.parsimUnpack(b);}
00643 
00655 class FindNodeResponse : public BaseResponseMessage
00656 {
00657   protected:
00658     bool siblings_var;
00659     NodeHandle *closestNodes_var; // array ptr
00660     unsigned int closestNodes_arraysize;
00661 
00662     // protected and unimplemented operator==(), to prevent accidental usage
00663     bool operator==(const FindNodeResponse&);
00664 
00665   public:
00666     FindNodeResponse(const char *name=NULL, int kind=0);
00667     FindNodeResponse(const FindNodeResponse& other);
00668     virtual ~FindNodeResponse();
00669     FindNodeResponse& operator=(const FindNodeResponse& other);
00670     virtual FindNodeResponse *dup() const {return new FindNodeResponse(*this);}
00671     virtual void parsimPack(cCommBuffer *b);
00672     virtual void parsimUnpack(cCommBuffer *b);
00673 
00674     // field getter/setter methods
00675     virtual bool getSiblings() const;
00676     virtual void setSiblings(bool siblings_var);
00677     virtual void setClosestNodesArraySize(unsigned int size);
00678     virtual unsigned int getClosestNodesArraySize() const;
00679     virtual NodeHandle& getClosestNodes(unsigned int k);
00680     virtual const NodeHandle& getClosestNodes(unsigned int k) const {return const_cast<FindNodeResponse*>(this)->getClosestNodes(k);}
00681     virtual void setClosestNodes(unsigned int k, const NodeHandle& closestNodes_var);
00682 };
00683 
00684 inline void doPacking(cCommBuffer *b, FindNodeResponse& obj) {obj.parsimPack(b);}
00685 inline void doUnpacking(cCommBuffer *b, FindNodeResponse& obj) {obj.parsimUnpack(b);}
00686 
00696 class FailedNodeCall : public BaseCallMessage
00697 {
00698   protected:
00699     TransportAddress failedNode_var;
00700 
00701     // protected and unimplemented operator==(), to prevent accidental usage
00702     bool operator==(const FailedNodeCall&);
00703 
00704   public:
00705     FailedNodeCall(const char *name=NULL, int kind=0);
00706     FailedNodeCall(const FailedNodeCall& other);
00707     virtual ~FailedNodeCall();
00708     FailedNodeCall& operator=(const FailedNodeCall& other);
00709     virtual FailedNodeCall *dup() const {return new FailedNodeCall(*this);}
00710     virtual void parsimPack(cCommBuffer *b);
00711     virtual void parsimUnpack(cCommBuffer *b);
00712 
00713     // field getter/setter methods
00714     virtual TransportAddress& getFailedNode();
00715     virtual const TransportAddress& getFailedNode() const {return const_cast<FailedNodeCall*>(this)->getFailedNode();}
00716     virtual void setFailedNode(const TransportAddress& failedNode_var);
00717 };
00718 
00719 inline void doPacking(cCommBuffer *b, FailedNodeCall& obj) {obj.parsimPack(b);}
00720 inline void doUnpacking(cCommBuffer *b, FailedNodeCall& obj) {obj.parsimUnpack(b);}
00721 
00731 class FailedNodeResponse : public BaseResponseMessage
00732 {
00733   protected:
00734     bool tryAgain_var;
00735 
00736     // protected and unimplemented operator==(), to prevent accidental usage
00737     bool operator==(const FailedNodeResponse&);
00738 
00739   public:
00740     FailedNodeResponse(const char *name=NULL, int kind=0);
00741     FailedNodeResponse(const FailedNodeResponse& other);
00742     virtual ~FailedNodeResponse();
00743     FailedNodeResponse& operator=(const FailedNodeResponse& other);
00744     virtual FailedNodeResponse *dup() const {return new FailedNodeResponse(*this);}
00745     virtual void parsimPack(cCommBuffer *b);
00746     virtual void parsimUnpack(cCommBuffer *b);
00747 
00748     // field getter/setter methods
00749     virtual bool getTryAgain() const;
00750     virtual void setTryAgain(bool tryAgain_var);
00751 };
00752 
00753 inline void doPacking(cCommBuffer *b, FailedNodeResponse& obj) {obj.parsimPack(b);}
00754 inline void doUnpacking(cCommBuffer *b, FailedNodeResponse& obj) {obj.parsimUnpack(b);}
00755 
00764 class PingCall : public BaseCallMessage
00765 {
00766   protected:
00767 
00768     // protected and unimplemented operator==(), to prevent accidental usage
00769     bool operator==(const PingCall&);
00770 
00771   public:
00772     PingCall(const char *name=NULL, int kind=0);
00773     PingCall(const PingCall& other);
00774     virtual ~PingCall();
00775     PingCall& operator=(const PingCall& other);
00776     virtual PingCall *dup() const {return new PingCall(*this);}
00777     virtual void parsimPack(cCommBuffer *b);
00778     virtual void parsimUnpack(cCommBuffer *b);
00779 
00780     // field getter/setter methods
00781 };
00782 
00783 inline void doPacking(cCommBuffer *b, PingCall& obj) {obj.parsimPack(b);}
00784 inline void doUnpacking(cCommBuffer *b, PingCall& obj) {obj.parsimUnpack(b);}
00785 
00794 class PingResponse : public BaseResponseMessage
00795 {
00796   protected:
00797 
00798     // protected and unimplemented operator==(), to prevent accidental usage
00799     bool operator==(const PingResponse&);
00800 
00801   public:
00802     PingResponse(const char *name=NULL, int kind=0);
00803     PingResponse(const PingResponse& other);
00804     virtual ~PingResponse();
00805     PingResponse& operator=(const PingResponse& other);
00806     virtual PingResponse *dup() const {return new PingResponse(*this);}
00807     virtual void parsimPack(cCommBuffer *b);
00808     virtual void parsimUnpack(cCommBuffer *b);
00809 
00810     // field getter/setter methods
00811 };
00812 
00813 inline void doPacking(cCommBuffer *b, PingResponse& obj) {obj.parsimPack(b);}
00814 inline void doUnpacking(cCommBuffer *b, PingResponse& obj) {obj.parsimUnpack(b);}
00815 
00826 class CompReadyMessage : public cPacket
00827 {
00828   protected:
00829     bool ready_var;
00830     int comp_var;
00831 
00832     // protected and unimplemented operator==(), to prevent accidental usage
00833     bool operator==(const CompReadyMessage&);
00834 
00835   public:
00836     CompReadyMessage(const char *name=NULL, int kind=0);
00837     CompReadyMessage(const CompReadyMessage& other);
00838     virtual ~CompReadyMessage();
00839     CompReadyMessage& operator=(const CompReadyMessage& other);
00840     virtual CompReadyMessage *dup() const {return new CompReadyMessage(*this);}
00841     virtual void parsimPack(cCommBuffer *b);
00842     virtual void parsimUnpack(cCommBuffer *b);
00843 
00844     // field getter/setter methods
00845     virtual bool getReady() const;
00846     virtual void setReady(bool ready_var);
00847     virtual int getComp() const;
00848     virtual void setComp(int comp_var);
00849 };
00850 
00851 inline void doPacking(cCommBuffer *b, CompReadyMessage& obj) {obj.parsimPack(b);}
00852 inline void doUnpacking(cCommBuffer *b, CompReadyMessage& obj) {obj.parsimUnpack(b);}
00853 
00862 class BootstrapLookupMessage : public BaseOverlayMessage
00863 {
00864   protected:
00865 
00866     // protected and unimplemented operator==(), to prevent accidental usage
00867     bool operator==(const BootstrapLookupMessage&);
00868 
00869   public:
00870     BootstrapLookupMessage(const char *name=NULL, int kind=0);
00871     BootstrapLookupMessage(const BootstrapLookupMessage& other);
00872     virtual ~BootstrapLookupMessage();
00873     BootstrapLookupMessage& operator=(const BootstrapLookupMessage& other);
00874     virtual BootstrapLookupMessage *dup() const {return new BootstrapLookupMessage(*this);}
00875     virtual void parsimPack(cCommBuffer *b);
00876     virtual void parsimUnpack(cCommBuffer *b);
00877 
00878     // field getter/setter methods
00879 };
00880 
00881 inline void doPacking(cCommBuffer *b, BootstrapLookupMessage& obj) {obj.parsimPack(b);}
00882 inline void doUnpacking(cCommBuffer *b, BootstrapLookupMessage& obj) {obj.parsimUnpack(b);}
00883 
00892 class NextHopCall : public BaseCallMessage
00893 {
00894   protected:
00895 
00896     // protected and unimplemented operator==(), to prevent accidental usage
00897     bool operator==(const NextHopCall&);
00898 
00899   public:
00900     NextHopCall(const char *name=NULL, int kind=0);
00901     NextHopCall(const NextHopCall& other);
00902     virtual ~NextHopCall();
00903     NextHopCall& operator=(const NextHopCall& other);
00904     virtual NextHopCall *dup() const {return new NextHopCall(*this);}
00905     virtual void parsimPack(cCommBuffer *b);
00906     virtual void parsimUnpack(cCommBuffer *b);
00907 
00908     // field getter/setter methods
00909 };
00910 
00911 inline void doPacking(cCommBuffer *b, NextHopCall& obj) {obj.parsimPack(b);}
00912 inline void doUnpacking(cCommBuffer *b, NextHopCall& obj) {obj.parsimUnpack(b);}
00913 
00922 class NextHopResponse : public BaseResponseMessage
00923 {
00924   protected:
00925 
00926     // protected and unimplemented operator==(), to prevent accidental usage
00927     bool operator==(const NextHopResponse&);
00928 
00929   public:
00930     NextHopResponse(const char *name=NULL, int kind=0);
00931     NextHopResponse(const NextHopResponse& other);
00932     virtual ~NextHopResponse();
00933     NextHopResponse& operator=(const NextHopResponse& other);
00934     virtual NextHopResponse *dup() const {return new NextHopResponse(*this);}
00935     virtual void parsimPack(cCommBuffer *b);
00936     virtual void parsimUnpack(cCommBuffer *b);
00937 
00938     // field getter/setter methods
00939 };
00940 
00941 inline void doPacking(cCommBuffer *b, NextHopResponse& obj) {obj.parsimPack(b);}
00942 inline void doUnpacking(cCommBuffer *b, NextHopResponse& obj) {obj.parsimUnpack(b);}
00943 
00953 class CommonAPIMessage : public cPacket
00954 {
00955   protected:
00956     int type_var;
00957 
00958     // protected and unimplemented operator==(), to prevent accidental usage
00959     bool operator==(const CommonAPIMessage&);
00960 
00961   public:
00962     CommonAPIMessage(const char *name=NULL, int kind=0);
00963     CommonAPIMessage(const CommonAPIMessage& other);
00964     virtual ~CommonAPIMessage();
00965     CommonAPIMessage& operator=(const CommonAPIMessage& other);
00966     virtual CommonAPIMessage *dup() const {return new CommonAPIMessage(*this);}
00967     virtual void parsimPack(cCommBuffer *b);
00968     virtual void parsimUnpack(cCommBuffer *b);
00969 
00970     // field getter/setter methods
00971     virtual int getType() const;
00972     virtual void setType(int type_var);
00973 };
00974 
00975 inline void doPacking(cCommBuffer *b, CommonAPIMessage& obj) {obj.parsimPack(b);}
00976 inline void doUnpacking(cCommBuffer *b, CommonAPIMessage& obj) {obj.parsimUnpack(b);}
00977 
00991 class KBRroute : public CommonAPIMessage
00992 {
00993   protected:
00994     OverlayKey destKey_var;
00995     int destComp_var;
00996     int srcComp_var;
00997     TransportAddress *sourceRoute_var; // array ptr
00998     unsigned int sourceRoute_arraysize;
00999     int routingType_var;
01000 
01001     // protected and unimplemented operator==(), to prevent accidental usage
01002     bool operator==(const KBRroute&);
01003 
01004   public:
01005     KBRroute(const char *name=NULL, int kind=0);
01006     KBRroute(const KBRroute& other);
01007     virtual ~KBRroute();
01008     KBRroute& operator=(const KBRroute& other);
01009     virtual KBRroute *dup() const {return new KBRroute(*this);}
01010     virtual void parsimPack(cCommBuffer *b);
01011     virtual void parsimUnpack(cCommBuffer *b);
01012 
01013     // field getter/setter methods
01014     virtual OverlayKey& getDestKey();
01015     virtual const OverlayKey& getDestKey() const {return const_cast<KBRroute*>(this)->getDestKey();}
01016     virtual void setDestKey(const OverlayKey& destKey_var);
01017     virtual int getDestComp() const;
01018     virtual void setDestComp(int destComp_var);
01019     virtual int getSrcComp() const;
01020     virtual void setSrcComp(int srcComp_var);
01021     virtual void setSourceRouteArraySize(unsigned int size);
01022     virtual unsigned int getSourceRouteArraySize() const;
01023     virtual TransportAddress& getSourceRoute(unsigned int k);
01024     virtual const TransportAddress& getSourceRoute(unsigned int k) const {return const_cast<KBRroute*>(this)->getSourceRoute(k);}
01025     virtual void setSourceRoute(unsigned int k, const TransportAddress& sourceRoute_var);
01026     virtual int getRoutingType() const;
01027     virtual void setRoutingType(int routingType_var);
01028 };
01029 
01030 inline void doPacking(cCommBuffer *b, KBRroute& obj) {obj.parsimPack(b);}
01031 inline void doUnpacking(cCommBuffer *b, KBRroute& obj) {obj.parsimUnpack(b);}
01032 
01043 class KBRforward : public CommonAPIMessage
01044 {
01045   protected:
01046     OverlayKey destKey_var;
01047     NodeHandle nextHopNode_var;
01048 
01049     // protected and unimplemented operator==(), to prevent accidental usage
01050     bool operator==(const KBRforward&);
01051 
01052   public:
01053     KBRforward(const char *name=NULL, int kind=0);
01054     KBRforward(const KBRforward& other);
01055     virtual ~KBRforward();
01056     KBRforward& operator=(const KBRforward& other);
01057     virtual KBRforward *dup() const {return new KBRforward(*this);}
01058     virtual void parsimPack(cCommBuffer *b);
01059     virtual void parsimUnpack(cCommBuffer *b);
01060 
01061     // field getter/setter methods
01062     virtual OverlayKey& getDestKey();
01063     virtual const OverlayKey& getDestKey() const {return const_cast<KBRforward*>(this)->getDestKey();}
01064     virtual void setDestKey(const OverlayKey& destKey_var);
01065     virtual NodeHandle& getNextHopNode();
01066     virtual const NodeHandle& getNextHopNode() const {return const_cast<KBRforward*>(this)->getNextHopNode();}
01067     virtual void setNextHopNode(const NodeHandle& nextHopNode_var);
01068 };
01069 
01070 inline void doPacking(cCommBuffer *b, KBRforward& obj) {obj.parsimPack(b);}
01071 inline void doUnpacking(cCommBuffer *b, KBRforward& obj) {obj.parsimUnpack(b);}
01072 
01082 class KBRdeliver : public CommonAPIMessage
01083 {
01084   protected:
01085     OverlayKey destKey_var;
01086 
01087     // protected and unimplemented operator==(), to prevent accidental usage
01088     bool operator==(const KBRdeliver&);
01089 
01090   public:
01091     KBRdeliver(const char *name=NULL, int kind=0);
01092     KBRdeliver(const KBRdeliver& other);
01093     virtual ~KBRdeliver();
01094     KBRdeliver& operator=(const KBRdeliver& other);
01095     virtual KBRdeliver *dup() const {return new KBRdeliver(*this);}
01096     virtual void parsimPack(cCommBuffer *b);
01097     virtual void parsimUnpack(cCommBuffer *b);
01098 
01099     // field getter/setter methods
01100     virtual OverlayKey& getDestKey();
01101     virtual const OverlayKey& getDestKey() const {return const_cast<KBRdeliver*>(this)->getDestKey();}
01102     virtual void setDestKey(const OverlayKey& destKey_var);
01103 };
01104 
01105 inline void doPacking(cCommBuffer *b, KBRdeliver& obj) {obj.parsimPack(b);}
01106 inline void doUnpacking(cCommBuffer *b, KBRdeliver& obj) {obj.parsimUnpack(b);}
01107 
01118 class KBRupdate : public CommonAPIMessage
01119 {
01120   protected:
01121     NodeHandle node_var;
01122     bool joined_var;
01123 
01124     // protected and unimplemented operator==(), to prevent accidental usage
01125     bool operator==(const KBRupdate&);
01126 
01127   public:
01128     KBRupdate(const char *name=NULL, int kind=0);
01129     KBRupdate(const KBRupdate& other);
01130     virtual ~KBRupdate();
01131     KBRupdate& operator=(const KBRupdate& other);
01132     virtual KBRupdate *dup() const {return new KBRupdate(*this);}
01133     virtual void parsimPack(cCommBuffer *b);
01134     virtual void parsimUnpack(cCommBuffer *b);
01135 
01136     // field getter/setter methods
01137     virtual NodeHandle& getNode();
01138     virtual const NodeHandle& getNode() const {return const_cast<KBRupdate*>(this)->getNode();}
01139     virtual void setNode(const NodeHandle& node_var);
01140     virtual bool getJoined() const;
01141     virtual void setJoined(bool joined_var);
01142 };
01143 
01144 inline void doPacking(cCommBuffer *b, KBRupdate& obj) {obj.parsimPack(b);}
01145 inline void doUnpacking(cCommBuffer *b, KBRupdate& obj) {obj.parsimUnpack(b);}
01146 
01163 class DhtDumpEntry : public cObject
01164 {
01165   protected:
01166     OverlayKey key_var;
01167     uint32_t kind_var;
01168     uint32_t id_var;
01169     BinaryValue value_var;
01170     int ttl_var;
01171     NodeHandle ownerNode_var;
01172     bool is_modifiable_var;
01173     bool responsible_var;
01174 
01175     // protected and unimplemented operator==(), to prevent accidental usage
01176     bool operator==(const DhtDumpEntry&);
01177 
01178   public:
01179     DhtDumpEntry();
01180     DhtDumpEntry(const DhtDumpEntry& other);
01181     virtual ~DhtDumpEntry();
01182     DhtDumpEntry& operator=(const DhtDumpEntry& other);
01183     virtual DhtDumpEntry *dup() const {return new DhtDumpEntry(*this);}
01184     virtual void parsimPack(cCommBuffer *b);
01185     virtual void parsimUnpack(cCommBuffer *b);
01186 
01187     // field getter/setter methods
01188     virtual OverlayKey& getKey();
01189     virtual const OverlayKey& getKey() const {return const_cast<DhtDumpEntry*>(this)->getKey();}
01190     virtual void setKey(const OverlayKey& key_var);
01191     virtual uint32_t getKind() const;
01192     virtual void setKind(uint32_t kind_var);
01193     virtual uint32_t getId() const;
01194     virtual void setId(uint32_t id_var);
01195     virtual BinaryValue& getValue();
01196     virtual const BinaryValue& getValue() const {return const_cast<DhtDumpEntry*>(this)->getValue();}
01197     virtual void setValue(const BinaryValue& value_var);
01198     virtual int getTtl() const;
01199     virtual void setTtl(int ttl_var);
01200     virtual NodeHandle& getOwnerNode();
01201     virtual const NodeHandle& getOwnerNode() const {return const_cast<DhtDumpEntry*>(this)->getOwnerNode();}
01202     virtual void setOwnerNode(const NodeHandle& ownerNode_var);
01203     virtual bool getIs_modifiable() const;
01204     virtual void setIs_modifiable(bool is_modifiable_var);
01205     virtual bool getResponsible() const;
01206     virtual void setResponsible(bool responsible_var);
01207 };
01208 
01209 inline void doPacking(cCommBuffer *b, DhtDumpEntry& obj) {obj.parsimPack(b);}
01210 inline void doUnpacking(cCommBuffer *b, DhtDumpEntry& obj) {obj.parsimUnpack(b);}
01211 
01226 class DHTputCAPICall : public BaseCallMessage
01227 {
01228   protected:
01229     OverlayKey key_var;
01230     uint32_t kind_var;
01231     uint32_t id_var;
01232     BinaryValue value_var;
01233     int ttl_var;
01234     bool isModifiable_var;
01235 
01236     // protected and unimplemented operator==(), to prevent accidental usage
01237     bool operator==(const DHTputCAPICall&);
01238 
01239   public:
01240     DHTputCAPICall(const char *name=NULL, int kind=0);
01241     DHTputCAPICall(const DHTputCAPICall& other);
01242     virtual ~DHTputCAPICall();
01243     DHTputCAPICall& operator=(const DHTputCAPICall& other);
01244     virtual DHTputCAPICall *dup() const {return new DHTputCAPICall(*this);}
01245     virtual void parsimPack(cCommBuffer *b);
01246     virtual void parsimUnpack(cCommBuffer *b);
01247 
01248     // field getter/setter methods
01249     virtual OverlayKey& getKey();
01250     virtual const OverlayKey& getKey() const {return const_cast<DHTputCAPICall*>(this)->getKey();}
01251     virtual void setKey(const OverlayKey& key_var);
01252     virtual uint32_t getKind() const;
01253     virtual void setKind(uint32_t kind_var);
01254     virtual uint32_t getId() const;
01255     virtual void setId(uint32_t id_var);
01256     virtual BinaryValue& getValue();
01257     virtual const BinaryValue& getValue() const {return const_cast<DHTputCAPICall*>(this)->getValue();}
01258     virtual void setValue(const BinaryValue& value_var);
01259     virtual int getTtl() const;
01260     virtual void setTtl(int ttl_var);
01261     virtual bool getIsModifiable() const;
01262     virtual void setIsModifiable(bool isModifiable_var);
01263 };
01264 
01265 inline void doPacking(cCommBuffer *b, DHTputCAPICall& obj) {obj.parsimPack(b);}
01266 inline void doUnpacking(cCommBuffer *b, DHTputCAPICall& obj) {obj.parsimUnpack(b);}
01267 
01279 class DHTgetCAPICall : public BaseCallMessage
01280 {
01281   protected:
01282     OverlayKey key_var;
01283     uint32_t kind_var;
01284     uint32_t id_var;
01285 
01286     // protected and unimplemented operator==(), to prevent accidental usage
01287     bool operator==(const DHTgetCAPICall&);
01288 
01289   public:
01290     DHTgetCAPICall(const char *name=NULL, int kind=0);
01291     DHTgetCAPICall(const DHTgetCAPICall& other);
01292     virtual ~DHTgetCAPICall();
01293     DHTgetCAPICall& operator=(const DHTgetCAPICall& other);
01294     virtual DHTgetCAPICall *dup() const {return new DHTgetCAPICall(*this);}
01295     virtual void parsimPack(cCommBuffer *b);
01296     virtual void parsimUnpack(cCommBuffer *b);
01297 
01298     // field getter/setter methods
01299     virtual OverlayKey& getKey();
01300     virtual const OverlayKey& getKey() const {return const_cast<DHTgetCAPICall*>(this)->getKey();}
01301     virtual void setKey(const OverlayKey& key_var);
01302     virtual uint32_t getKind() const;
01303     virtual void setKind(uint32_t kind_var);
01304     virtual uint32_t getId() const;
01305     virtual void setId(uint32_t id_var);
01306 };
01307 
01308 inline void doPacking(cCommBuffer *b, DHTgetCAPICall& obj) {obj.parsimPack(b);}
01309 inline void doUnpacking(cCommBuffer *b, DHTgetCAPICall& obj) {obj.parsimUnpack(b);}
01310 
01322 class DHTputCAPIResponse : public BaseResponseMessage
01323 {
01324   protected:
01325     OverlayKey key_var;
01326     BinaryValue value_var;
01327     bool isSuccess_var;
01328 
01329     // protected and unimplemented operator==(), to prevent accidental usage
01330     bool operator==(const DHTputCAPIResponse&);
01331 
01332   public:
01333     DHTputCAPIResponse(const char *name=NULL, int kind=0);
01334     DHTputCAPIResponse(const DHTputCAPIResponse& other);
01335     virtual ~DHTputCAPIResponse();
01336     DHTputCAPIResponse& operator=(const DHTputCAPIResponse& other);
01337     virtual DHTputCAPIResponse *dup() const {return new DHTputCAPIResponse(*this);}
01338     virtual void parsimPack(cCommBuffer *b);
01339     virtual void parsimUnpack(cCommBuffer *b);
01340 
01341     // field getter/setter methods
01342     virtual OverlayKey& getKey();
01343     virtual const OverlayKey& getKey() const {return const_cast<DHTputCAPIResponse*>(this)->getKey();}
01344     virtual void setKey(const OverlayKey& key_var);
01345     virtual BinaryValue& getValue();
01346     virtual const BinaryValue& getValue() const {return const_cast<DHTputCAPIResponse*>(this)->getValue();}
01347     virtual void setValue(const BinaryValue& value_var);
01348     virtual bool getIsSuccess() const;
01349     virtual void setIsSuccess(bool isSuccess_var);
01350 };
01351 
01352 inline void doPacking(cCommBuffer *b, DHTputCAPIResponse& obj) {obj.parsimPack(b);}
01353 inline void doUnpacking(cCommBuffer *b, DHTputCAPIResponse& obj) {obj.parsimUnpack(b);}
01354 
01365 class DHTgetCAPIResponse : public BaseResponseMessage
01366 {
01367   protected:
01368     DhtDumpEntry *result_var; // array ptr
01369     unsigned int result_arraysize;
01370     bool isSuccess_var;
01371 
01372     // protected and unimplemented operator==(), to prevent accidental usage
01373     bool operator==(const DHTgetCAPIResponse&);
01374 
01375   public:
01376     DHTgetCAPIResponse(const char *name=NULL, int kind=0);
01377     DHTgetCAPIResponse(const DHTgetCAPIResponse& other);
01378     virtual ~DHTgetCAPIResponse();
01379     DHTgetCAPIResponse& operator=(const DHTgetCAPIResponse& other);
01380     virtual DHTgetCAPIResponse *dup() const {return new DHTgetCAPIResponse(*this);}
01381     virtual void parsimPack(cCommBuffer *b);
01382     virtual void parsimUnpack(cCommBuffer *b);
01383 
01384     // field getter/setter methods
01385     virtual void setResultArraySize(unsigned int size);
01386     virtual unsigned int getResultArraySize() const;
01387     virtual DhtDumpEntry& getResult(unsigned int k);
01388     virtual const DhtDumpEntry& getResult(unsigned int k) const {return const_cast<DHTgetCAPIResponse*>(this)->getResult(k);}
01389     virtual void setResult(unsigned int k, const DhtDumpEntry& result_var);
01390     virtual bool getIsSuccess() const;
01391     virtual void setIsSuccess(bool isSuccess_var);
01392 };
01393 
01394 inline void doPacking(cCommBuffer *b, DHTgetCAPIResponse& obj) {obj.parsimPack(b);}
01395 inline void doUnpacking(cCommBuffer *b, DHTgetCAPIResponse& obj) {obj.parsimUnpack(b);}
01396 
01405 class DHTdumpCall : public BaseCallMessage
01406 {
01407   protected:
01408 
01409     // protected and unimplemented operator==(), to prevent accidental usage
01410     bool operator==(const DHTdumpCall&);
01411 
01412   public:
01413     DHTdumpCall(const char *name=NULL, int kind=0);
01414     DHTdumpCall(const DHTdumpCall& other);
01415     virtual ~DHTdumpCall();
01416     DHTdumpCall& operator=(const DHTdumpCall& other);
01417     virtual DHTdumpCall *dup() const {return new DHTdumpCall(*this);}
01418     virtual void parsimPack(cCommBuffer *b);
01419     virtual void parsimUnpack(cCommBuffer *b);
01420 
01421     // field getter/setter methods
01422 };
01423 
01424 inline void doPacking(cCommBuffer *b, DHTdumpCall& obj) {obj.parsimPack(b);}
01425 inline void doUnpacking(cCommBuffer *b, DHTdumpCall& obj) {obj.parsimUnpack(b);}
01426 
01436 class DHTdumpResponse : public BaseResponseMessage
01437 {
01438   protected:
01439     DhtDumpEntry *record_var; // array ptr
01440     unsigned int record_arraysize;
01441 
01442     // protected and unimplemented operator==(), to prevent accidental usage
01443     bool operator==(const DHTdumpResponse&);
01444 
01445   public:
01446     DHTdumpResponse(const char *name=NULL, int kind=0);
01447     DHTdumpResponse(const DHTdumpResponse& other);
01448     virtual ~DHTdumpResponse();
01449     DHTdumpResponse& operator=(const DHTdumpResponse& other);
01450     virtual DHTdumpResponse *dup() const {return new DHTdumpResponse(*this);}
01451     virtual void parsimPack(cCommBuffer *b);
01452     virtual void parsimUnpack(cCommBuffer *b);
01453 
01454     // field getter/setter methods
01455     virtual void setRecordArraySize(unsigned int size);
01456     virtual unsigned int getRecordArraySize() const;
01457     virtual DhtDumpEntry& getRecord(unsigned int k);
01458     virtual const DhtDumpEntry& getRecord(unsigned int k) const {return const_cast<DHTdumpResponse*>(this)->getRecord(k);}
01459     virtual void setRecord(unsigned int k, const DhtDumpEntry& record_var);
01460 };
01461 
01462 inline void doPacking(cCommBuffer *b, DHTdumpResponse& obj) {obj.parsimPack(b);}
01463 inline void doUnpacking(cCommBuffer *b, DHTdumpResponse& obj) {obj.parsimUnpack(b);}
01464 
01476 class LookupCall : public BaseCallMessage
01477 {
01478   protected:
01479     OverlayKey key_var;
01480     int numSiblings_var;
01481     int routingType_var;
01482 
01483     // protected and unimplemented operator==(), to prevent accidental usage
01484     bool operator==(const LookupCall&);
01485 
01486   public:
01487     LookupCall(const char *name=NULL, int kind=0);
01488     LookupCall(const LookupCall& other);
01489     virtual ~LookupCall();
01490     LookupCall& operator=(const LookupCall& other);
01491     virtual LookupCall *dup() const {return new LookupCall(*this);}
01492     virtual void parsimPack(cCommBuffer *b);
01493     virtual void parsimUnpack(cCommBuffer *b);
01494 
01495     // field getter/setter methods
01496     virtual OverlayKey& getKey();
01497     virtual const OverlayKey& getKey() const {return const_cast<LookupCall*>(this)->getKey();}
01498     virtual void setKey(const OverlayKey& key_var);
01499     virtual int getNumSiblings() const;
01500     virtual void setNumSiblings(int numSiblings_var);
01501     virtual int getRoutingType() const;
01502     virtual void setRoutingType(int routingType_var);
01503 };
01504 
01505 inline void doPacking(cCommBuffer *b, LookupCall& obj) {obj.parsimPack(b);}
01506 inline void doUnpacking(cCommBuffer *b, LookupCall& obj) {obj.parsimUnpack(b);}
01507 
01520 class LookupResponse : public BaseResponseMessage
01521 {
01522   protected:
01523     OverlayKey key_var;
01524     int hopCount_var;
01525     bool isValid_var;
01526     NodeHandle *siblings_var; // array ptr
01527     unsigned int siblings_arraysize;
01528 
01529     // protected and unimplemented operator==(), to prevent accidental usage
01530     bool operator==(const LookupResponse&);
01531 
01532   public:
01533     LookupResponse(const char *name=NULL, int kind=0);
01534     LookupResponse(const LookupResponse& other);
01535     virtual ~LookupResponse();
01536     LookupResponse& operator=(const LookupResponse& other);
01537     virtual LookupResponse *dup() const {return new LookupResponse(*this);}
01538     virtual void parsimPack(cCommBuffer *b);
01539     virtual void parsimUnpack(cCommBuffer *b);
01540 
01541     // field getter/setter methods
01542     virtual OverlayKey& getKey();
01543     virtual const OverlayKey& getKey() const {return const_cast<LookupResponse*>(this)->getKey();}
01544     virtual void setKey(const OverlayKey& key_var);
01545     virtual int getHopCount() const;
01546     virtual void setHopCount(int hopCount_var);
01547     virtual bool getIsValid() const;
01548     virtual void setIsValid(bool isValid_var);
01549     virtual void setSiblingsArraySize(unsigned int size);
01550     virtual unsigned int getSiblingsArraySize() const;
01551     virtual NodeHandle& getSiblings(unsigned int k);
01552     virtual const NodeHandle& getSiblings(unsigned int k) const {return const_cast<LookupResponse*>(this)->getSiblings(k);}
01553     virtual void setSiblings(unsigned int k, const NodeHandle& siblings_var);
01554 };
01555 
01556 inline void doPacking(cCommBuffer *b, LookupResponse& obj) {obj.parsimPack(b);}
01557 inline void doUnpacking(cCommBuffer *b, LookupResponse& obj) {obj.parsimUnpack(b);}
01558 
01572 class P2pnsRegisterCall : public BaseCallMessage
01573 {
01574   protected:
01575     BinaryValue p2pName_var;
01576     uint32_t kind_var;
01577     uint32_t id_var;
01578     BinaryValue address_var;
01579     int ttl_var;
01580 
01581     // protected and unimplemented operator==(), to prevent accidental usage
01582     bool operator==(const P2pnsRegisterCall&);
01583 
01584   public:
01585     P2pnsRegisterCall(const char *name=NULL, int kind=0);
01586     P2pnsRegisterCall(const P2pnsRegisterCall& other);
01587     virtual ~P2pnsRegisterCall();
01588     P2pnsRegisterCall& operator=(const P2pnsRegisterCall& other);
01589     virtual P2pnsRegisterCall *dup() const {return new P2pnsRegisterCall(*this);}
01590     virtual void parsimPack(cCommBuffer *b);
01591     virtual void parsimUnpack(cCommBuffer *b);
01592 
01593     // field getter/setter methods
01594     virtual BinaryValue& getP2pName();
01595     virtual const BinaryValue& getP2pName() const {return const_cast<P2pnsRegisterCall*>(this)->getP2pName();}
01596     virtual void setP2pName(const BinaryValue& p2pName_var);
01597     virtual uint32_t getKind() const;
01598     virtual void setKind(uint32_t kind_var);
01599     virtual uint32_t getId() const;
01600     virtual void setId(uint32_t id_var);
01601     virtual BinaryValue& getAddress();
01602     virtual const BinaryValue& getAddress() const {return const_cast<P2pnsRegisterCall*>(this)->getAddress();}
01603     virtual void setAddress(const BinaryValue& address_var);
01604     virtual int getTtl() const;
01605     virtual void setTtl(int ttl_var);
01606 };
01607 
01608 inline void doPacking(cCommBuffer *b, P2pnsRegisterCall& obj) {obj.parsimPack(b);}
01609 inline void doUnpacking(cCommBuffer *b, P2pnsRegisterCall& obj) {obj.parsimUnpack(b);}
01610 
01622 class P2pnsRegisterResponse : public BaseResponseMessage
01623 {
01624   protected:
01625     BinaryValue p2pName_var;
01626     BinaryValue address_var;
01627     bool isSuccess_var;
01628 
01629     // protected and unimplemented operator==(), to prevent accidental usage
01630     bool operator==(const P2pnsRegisterResponse&);
01631 
01632   public:
01633     P2pnsRegisterResponse(const char *name=NULL, int kind=0);
01634     P2pnsRegisterResponse(const P2pnsRegisterResponse& other);
01635     virtual ~P2pnsRegisterResponse();
01636     P2pnsRegisterResponse& operator=(const P2pnsRegisterResponse& other);
01637     virtual P2pnsRegisterResponse *dup() const {return new P2pnsRegisterResponse(*this);}
01638     virtual void parsimPack(cCommBuffer *b);
01639     virtual void parsimUnpack(cCommBuffer *b);
01640 
01641     // field getter/setter methods
01642     virtual BinaryValue& getP2pName();
01643     virtual const BinaryValue& getP2pName() const {return const_cast<P2pnsRegisterResponse*>(this)->getP2pName();}
01644     virtual void setP2pName(const BinaryValue& p2pName_var);
01645     virtual BinaryValue& getAddress();
01646     virtual const BinaryValue& getAddress() const {return const_cast<P2pnsRegisterResponse*>(this)->getAddress();}
01647     virtual void setAddress(const BinaryValue& address_var);
01648     virtual bool getIsSuccess() const;
01649     virtual void setIsSuccess(bool isSuccess_var);
01650 };
01651 
01652 inline void doPacking(cCommBuffer *b, P2pnsRegisterResponse& obj) {obj.parsimPack(b);}
01653 inline void doUnpacking(cCommBuffer *b, P2pnsRegisterResponse& obj) {obj.parsimUnpack(b);}
01654 
01666 class P2pnsResolveCall : public BaseCallMessage
01667 {
01668   protected:
01669     BinaryValue p2pName_var;
01670     uint32_t kind_var;
01671     uint32_t id_var;
01672 
01673     // protected and unimplemented operator==(), to prevent accidental usage
01674     bool operator==(const P2pnsResolveCall&);
01675 
01676   public:
01677     P2pnsResolveCall(const char *name=NULL, int kind=0);
01678     P2pnsResolveCall(const P2pnsResolveCall& other);
01679     virtual ~P2pnsResolveCall();
01680     P2pnsResolveCall& operator=(const P2pnsResolveCall& other);
01681     virtual P2pnsResolveCall *dup() const {return new P2pnsResolveCall(*this);}
01682     virtual void parsimPack(cCommBuffer *b);
01683     virtual void parsimUnpack(cCommBuffer *b);
01684 
01685     // field getter/setter methods
01686     virtual BinaryValue& getP2pName();
01687     virtual const BinaryValue& getP2pName() const {return const_cast<P2pnsResolveCall*>(this)->getP2pName();}
01688     virtual void setP2pName(const BinaryValue& p2pName_var);
01689     virtual uint32_t getKind() const;
01690     virtual void setKind(uint32_t kind_var);
01691     virtual uint32_t getId() const;
01692     virtual void setId(uint32_t id_var);
01693 };
01694 
01695 inline void doPacking(cCommBuffer *b, P2pnsResolveCall& obj) {obj.parsimPack(b);}
01696 inline void doUnpacking(cCommBuffer *b, P2pnsResolveCall& obj) {obj.parsimUnpack(b);}
01697 
01711 class P2pnsResolveResponse : public BaseResponseMessage
01712 {
01713   protected:
01714     BinaryValue p2pName_var;
01715     BinaryValue *address_var; // array ptr
01716     unsigned int address_arraysize;
01717     uint32_t *kind_var; // array ptr
01718     unsigned int kind_arraysize;
01719     uint32_t *id_var; // array ptr
01720     unsigned int id_arraysize;
01721     bool isSuccess_var;
01722 
01723     // protected and unimplemented operator==(), to prevent accidental usage
01724     bool operator==(const P2pnsResolveResponse&);
01725 
01726   public:
01727     P2pnsResolveResponse(const char *name=NULL, int kind=0);
01728     P2pnsResolveResponse(const P2pnsResolveResponse& other);
01729     virtual ~P2pnsResolveResponse();
01730     P2pnsResolveResponse& operator=(const P2pnsResolveResponse& other);
01731     virtual P2pnsResolveResponse *dup() const {return new P2pnsResolveResponse(*this);}
01732     virtual void parsimPack(cCommBuffer *b);
01733     virtual void parsimUnpack(cCommBuffer *b);
01734 
01735     // field getter/setter methods
01736     virtual BinaryValue& getP2pName();
01737     virtual const BinaryValue& getP2pName() const {return const_cast<P2pnsResolveResponse*>(this)->getP2pName();}
01738     virtual void setP2pName(const BinaryValue& p2pName_var);
01739     virtual void setAddressArraySize(unsigned int size);
01740     virtual unsigned int getAddressArraySize() const;
01741     virtual BinaryValue& getAddress(unsigned int k);
01742     virtual const BinaryValue& getAddress(unsigned int k) const {return const_cast<P2pnsResolveResponse*>(this)->getAddress(k);}
01743     virtual void setAddress(unsigned int k, const BinaryValue& address_var);
01744     virtual void setKindArraySize(unsigned int size);
01745     virtual unsigned int getKindArraySize() const;
01746     virtual uint32_t getKind(unsigned int k) const;
01747     virtual void setKind(unsigned int k, uint32_t kind_var);
01748     virtual void setIdArraySize(unsigned int size);
01749     virtual unsigned int getIdArraySize() const;
01750     virtual uint32_t getId(unsigned int k) const;
01751     virtual void setId(unsigned int k, uint32_t id_var);
01752     virtual bool getIsSuccess() const;
01753     virtual void setIsSuccess(bool isSuccess_var);
01754 };
01755 
01756 inline void doPacking(cCommBuffer *b, P2pnsResolveResponse& obj) {obj.parsimPack(b);}
01757 inline void doUnpacking(cCommBuffer *b, P2pnsResolveResponse& obj) {obj.parsimUnpack(b);}
01758 
01776 class OverlayCtrlInfo : public cObject
01777 {
01778   protected:
01779     TransportAddress lastHop_var;
01780     NodeHandle srcNode_var;
01781     NodeHandle srcRoute_var;
01782     int hopCount_var;
01783     TransportAddress *visitedHops_var; // array ptr
01784     unsigned int visitedHops_arraysize;
01785     int srcComp_var;
01786     int destComp_var;
01787     int transportType_var;
01788     int routingType_var;
01789 
01790     // protected and unimplemented operator==(), to prevent accidental usage
01791     bool operator==(const OverlayCtrlInfo&);
01792 
01793   public:
01794     OverlayCtrlInfo();
01795     OverlayCtrlInfo(const OverlayCtrlInfo& other);
01796     virtual ~OverlayCtrlInfo();
01797     OverlayCtrlInfo& operator=(const OverlayCtrlInfo& other);
01798     virtual OverlayCtrlInfo *dup() const {return new OverlayCtrlInfo(*this);}
01799     virtual void parsimPack(cCommBuffer *b);
01800     virtual void parsimUnpack(cCommBuffer *b);
01801 
01802     // field getter/setter methods
01803     virtual TransportAddress& getLastHop();
01804     virtual const TransportAddress& getLastHop() const {return const_cast<OverlayCtrlInfo*>(this)->getLastHop();}
01805     virtual void setLastHop(const TransportAddress& lastHop_var);
01806     virtual NodeHandle& getSrcNode();
01807     virtual const NodeHandle& getSrcNode() const {return const_cast<OverlayCtrlInfo*>(this)->getSrcNode();}
01808     virtual void setSrcNode(const NodeHandle& srcNode_var);
01809     virtual NodeHandle& getSrcRoute();
01810     virtual const NodeHandle& getSrcRoute() const {return const_cast<OverlayCtrlInfo*>(this)->getSrcRoute();}
01811     virtual void setSrcRoute(const NodeHandle& srcRoute_var);
01812     virtual int getHopCount() const;
01813     virtual void setHopCount(int hopCount_var);
01814     virtual void setVisitedHopsArraySize(unsigned int size);
01815     virtual unsigned int getVisitedHopsArraySize() const;
01816     virtual TransportAddress& getVisitedHops(unsigned int k);
01817     virtual const TransportAddress& getVisitedHops(unsigned int k) const {return const_cast<OverlayCtrlInfo*>(this)->getVisitedHops(k);}
01818     virtual void setVisitedHops(unsigned int k, const TransportAddress& visitedHops_var);
01819     virtual int getSrcComp() const;
01820     virtual void setSrcComp(int srcComp_var);
01821     virtual int getDestComp() const;
01822     virtual void setDestComp(int destComp_var);
01823     virtual int getTransportType() const;
01824     virtual void setTransportType(int transportType_var);
01825     virtual int getRoutingType() const;
01826     virtual void setRoutingType(int routingType_var);
01827 };
01828 
01829 inline void doPacking(cCommBuffer *b, OverlayCtrlInfo& obj) {obj.parsimPack(b);}
01830 inline void doUnpacking(cCommBuffer *b, OverlayCtrlInfo& obj) {obj.parsimUnpack(b);}
01831 
01841 class ALMMessage : public cPacket
01842 {
01843   protected:
01844     OverlayKey groupId_var;
01845 
01846     // protected and unimplemented operator==(), to prevent accidental usage
01847     bool operator==(const ALMMessage&);
01848 
01849   public:
01850     ALMMessage(const char *name=NULL, int kind=0);
01851     ALMMessage(const ALMMessage& other);
01852     virtual ~ALMMessage();
01853     ALMMessage& operator=(const ALMMessage& other);
01854     virtual ALMMessage *dup() const {return new ALMMessage(*this);}
01855     virtual void parsimPack(cCommBuffer *b);
01856     virtual void parsimUnpack(cCommBuffer *b);
01857 
01858     // field getter/setter methods
01859     virtual OverlayKey& getGroupId();
01860     virtual const OverlayKey& getGroupId() const {return const_cast<ALMMessage*>(this)->getGroupId();}
01861     virtual void setGroupId(const OverlayKey& groupId_var);
01862 };
01863 
01864 inline void doPacking(cCommBuffer *b, ALMMessage& obj) {obj.parsimPack(b);}
01865 inline void doUnpacking(cCommBuffer *b, ALMMessage& obj) {obj.parsimUnpack(b);}
01866 
01875 class ALMCreateMessage : public ALMMessage
01876 {
01877   protected:
01878 
01879     // protected and unimplemented operator==(), to prevent accidental usage
01880     bool operator==(const ALMCreateMessage&);
01881 
01882   public:
01883     ALMCreateMessage(const char *name=NULL, int kind=0);
01884     ALMCreateMessage(const ALMCreateMessage& other);
01885     virtual ~ALMCreateMessage();
01886     ALMCreateMessage& operator=(const ALMCreateMessage& other);
01887     virtual ALMCreateMessage *dup() const {return new ALMCreateMessage(*this);}
01888     virtual void parsimPack(cCommBuffer *b);
01889     virtual void parsimUnpack(cCommBuffer *b);
01890 
01891     // field getter/setter methods
01892 };
01893 
01894 inline void doPacking(cCommBuffer *b, ALMCreateMessage& obj) {obj.parsimPack(b);}
01895 inline void doUnpacking(cCommBuffer *b, ALMCreateMessage& obj) {obj.parsimUnpack(b);}
01896 
01905 class ALMDeleteMessage : public ALMMessage
01906 {
01907   protected:
01908 
01909     // protected and unimplemented operator==(), to prevent accidental usage
01910     bool operator==(const ALMDeleteMessage&);
01911 
01912   public:
01913     ALMDeleteMessage(const char *name=NULL, int kind=0);
01914     ALMDeleteMessage(const ALMDeleteMessage& other);
01915     virtual ~ALMDeleteMessage();
01916     ALMDeleteMessage& operator=(const ALMDeleteMessage& other);
01917     virtual ALMDeleteMessage *dup() const {return new ALMDeleteMessage(*this);}
01918     virtual void parsimPack(cCommBuffer *b);
01919     virtual void parsimUnpack(cCommBuffer *b);
01920 
01921     // field getter/setter methods
01922 };
01923 
01924 inline void doPacking(cCommBuffer *b, ALMDeleteMessage& obj) {obj.parsimPack(b);}
01925 inline void doUnpacking(cCommBuffer *b, ALMDeleteMessage& obj) {obj.parsimUnpack(b);}
01926 
01935 class ALMSubscribeMessage : public ALMMessage
01936 {
01937   protected:
01938 
01939     // protected and unimplemented operator==(), to prevent accidental usage
01940     bool operator==(const ALMSubscribeMessage&);
01941 
01942   public:
01943     ALMSubscribeMessage(const char *name=NULL, int kind=0);
01944     ALMSubscribeMessage(const ALMSubscribeMessage& other);
01945     virtual ~ALMSubscribeMessage();
01946     ALMSubscribeMessage& operator=(const ALMSubscribeMessage& other);
01947     virtual ALMSubscribeMessage *dup() const {return new ALMSubscribeMessage(*this);}
01948     virtual void parsimPack(cCommBuffer *b);
01949     virtual void parsimUnpack(cCommBuffer *b);
01950 
01951     // field getter/setter methods
01952 };
01953 
01954 inline void doPacking(cCommBuffer *b, ALMSubscribeMessage& obj) {obj.parsimPack(b);}
01955 inline void doUnpacking(cCommBuffer *b, ALMSubscribeMessage& obj) {obj.parsimUnpack(b);}
01956 
01965 class ALMLeaveMessage : public ALMMessage
01966 {
01967   protected:
01968 
01969     // protected and unimplemented operator==(), to prevent accidental usage
01970     bool operator==(const ALMLeaveMessage&);
01971 
01972   public:
01973     ALMLeaveMessage(const char *name=NULL, int kind=0);
01974     ALMLeaveMessage(const ALMLeaveMessage& other);
01975     virtual ~ALMLeaveMessage();
01976     ALMLeaveMessage& operator=(const ALMLeaveMessage& other);
01977     virtual ALMLeaveMessage *dup() const {return new ALMLeaveMessage(*this);}
01978     virtual void parsimPack(cCommBuffer *b);
01979     virtual void parsimUnpack(cCommBuffer *b);
01980 
01981     // field getter/setter methods
01982 };
01983 
01984 inline void doPacking(cCommBuffer *b, ALMLeaveMessage& obj) {obj.parsimPack(b);}
01985 inline void doUnpacking(cCommBuffer *b, ALMLeaveMessage& obj) {obj.parsimUnpack(b);}
01986 
01995 class ALMMulticastMessage : public ALMMessage
01996 {
01997   protected:
01998 
01999     // protected and unimplemented operator==(), to prevent accidental usage
02000     bool operator==(const ALMMulticastMessage&);
02001 
02002   public:
02003     ALMMulticastMessage(const char *name=NULL, int kind=0);
02004     ALMMulticastMessage(const ALMMulticastMessage& other);
02005     virtual ~ALMMulticastMessage();
02006     ALMMulticastMessage& operator=(const ALMMulticastMessage& other);
02007     virtual ALMMulticastMessage *dup() const {return new ALMMulticastMessage(*this);}
02008     virtual void parsimPack(cCommBuffer *b);
02009     virtual void parsimUnpack(cCommBuffer *b);
02010 
02011     // field getter/setter methods
02012 };
02013 
02014 inline void doPacking(cCommBuffer *b, ALMMulticastMessage& obj) {obj.parsimPack(b);}
02015 inline void doUnpacking(cCommBuffer *b, ALMMulticastMessage& obj) {obj.parsimUnpack(b);}
02016 
02025 class ALMAnycastMessage : public ALMMessage
02026 {
02027   protected:
02028 
02029     // protected and unimplemented operator==(), to prevent accidental usage
02030     bool operator==(const ALMAnycastMessage&);
02031 
02032   public:
02033     ALMAnycastMessage(const char *name=NULL, int kind=0);
02034     ALMAnycastMessage(const ALMAnycastMessage& other);
02035     virtual ~ALMAnycastMessage();
02036     ALMAnycastMessage& operator=(const ALMAnycastMessage& other);
02037     virtual ALMAnycastMessage *dup() const {return new ALMAnycastMessage(*this);}
02038     virtual void parsimPack(cCommBuffer *b);
02039     virtual void parsimUnpack(cCommBuffer *b);
02040 
02041     // field getter/setter methods
02042 };
02043 
02044 inline void doPacking(cCommBuffer *b, ALMAnycastMessage& obj) {obj.parsimPack(b);}
02045 inline void doUnpacking(cCommBuffer *b, ALMAnycastMessage& obj) {obj.parsimUnpack(b);}
02046 
02056 class GameAPIMessage : public BaseOverlayMessage
02057 {
02058   protected:
02059     int command_var;
02060 
02061     // protected and unimplemented operator==(), to prevent accidental usage
02062     bool operator==(const GameAPIMessage&);
02063 
02064   public:
02065     GameAPIMessage(const char *name=NULL, int kind=0);
02066     GameAPIMessage(const GameAPIMessage& other);
02067     virtual ~GameAPIMessage();
02068     GameAPIMessage& operator=(const GameAPIMessage& other);
02069     virtual GameAPIMessage *dup() const {return new GameAPIMessage(*this);}
02070     virtual void parsimPack(cCommBuffer *b);
02071     virtual void parsimUnpack(cCommBuffer *b);
02072 
02073     // field getter/setter methods
02074     virtual int getCommand() const;
02075     virtual void setCommand(int command_var);
02076 };
02077 
02078 inline void doPacking(cCommBuffer *b, GameAPIMessage& obj) {obj.parsimPack(b);}
02079 inline void doUnpacking(cCommBuffer *b, GameAPIMessage& obj) {obj.parsimUnpack(b);}
02080 
02092 class GameAPIListMessage : public GameAPIMessage
02093 {
02094   protected:
02095     NodeHandle *removeNeighbor_var; // array ptr
02096     unsigned int removeNeighbor_arraysize;
02097     NodeHandle *addNeighbor_var; // array ptr
02098     unsigned int addNeighbor_arraysize;
02099     Vector2D *neighborPosition_var; // array ptr
02100     unsigned int neighborPosition_arraysize;
02101 
02102     // protected and unimplemented operator==(), to prevent accidental usage
02103     bool operator==(const GameAPIListMessage&);
02104 
02105   public:
02106     GameAPIListMessage(const char *name=NULL, int kind=0);
02107     GameAPIListMessage(const GameAPIListMessage& other);
02108     virtual ~GameAPIListMessage();
02109     GameAPIListMessage& operator=(const GameAPIListMessage& other);
02110     virtual GameAPIListMessage *dup() const {return new GameAPIListMessage(*this);}
02111     virtual void parsimPack(cCommBuffer *b);
02112     virtual void parsimUnpack(cCommBuffer *b);
02113 
02114     // field getter/setter methods
02115     virtual void setRemoveNeighborArraySize(unsigned int size);
02116     virtual unsigned int getRemoveNeighborArraySize() const;
02117     virtual NodeHandle& getRemoveNeighbor(unsigned int k);
02118     virtual const NodeHandle& getRemoveNeighbor(unsigned int k) const {return const_cast<GameAPIListMessage*>(this)->getRemoveNeighbor(k);}
02119     virtual void setRemoveNeighbor(unsigned int k, const NodeHandle& removeNeighbor_var);
02120     virtual void setAddNeighborArraySize(unsigned int size);
02121     virtual unsigned int getAddNeighborArraySize() const;
02122     virtual NodeHandle& getAddNeighbor(unsigned int k);
02123     virtual const NodeHandle& getAddNeighbor(unsigned int k) const {return const_cast<GameAPIListMessage*>(this)->getAddNeighbor(k);}
02124     virtual void setAddNeighbor(unsigned int k, const NodeHandle& addNeighbor_var);
02125     virtual void setNeighborPositionArraySize(unsigned int size);
02126     virtual unsigned int getNeighborPositionArraySize() const;
02127     virtual Vector2D& getNeighborPosition(unsigned int k);
02128     virtual const Vector2D& getNeighborPosition(unsigned int k) const {return const_cast<GameAPIListMessage*>(this)->getNeighborPosition(k);}
02129     virtual void setNeighborPosition(unsigned int k, const Vector2D& neighborPosition_var);
02130 };
02131 
02132 inline void doPacking(cCommBuffer *b, GameAPIListMessage& obj) {obj.parsimPack(b);}
02133 inline void doUnpacking(cCommBuffer *b, GameAPIListMessage& obj) {obj.parsimUnpack(b);}
02134 
02144 class GameAPIPositionMessage : public GameAPIMessage
02145 {
02146   protected:
02147     Vector2D position_var;
02148 
02149     // protected and unimplemented operator==(), to prevent accidental usage
02150     bool operator==(const GameAPIPositionMessage&);
02151 
02152   public:
02153     GameAPIPositionMessage(const char *name=NULL, int kind=0);
02154     GameAPIPositionMessage(const GameAPIPositionMessage& other);
02155     virtual ~GameAPIPositionMessage();
02156     GameAPIPositionMessage& operator=(const GameAPIPositionMessage& other);
02157     virtual GameAPIPositionMessage *dup() const {return new GameAPIPositionMessage(*this);}
02158     virtual void parsimPack(cCommBuffer *b);
02159     virtual void parsimUnpack(cCommBuffer *b);
02160 
02161     // field getter/setter methods
02162     virtual Vector2D& getPosition();
02163     virtual const Vector2D& getPosition() const {return const_cast<GameAPIPositionMessage*>(this)->getPosition();}
02164     virtual void setPosition(const Vector2D& position_var);
02165 };
02166 
02167 inline void doPacking(cCommBuffer *b, GameAPIPositionMessage& obj) {obj.parsimPack(b);}
02168 inline void doUnpacking(cCommBuffer *b, GameAPIPositionMessage& obj) {obj.parsimUnpack(b);}
02169 
02179 class GameAPIResizeAOIMessage : public GameAPIMessage
02180 {
02181   protected:
02182     double AOIsize_var;
02183 
02184     // protected and unimplemented operator==(), to prevent accidental usage
02185     bool operator==(const GameAPIResizeAOIMessage&);
02186 
02187   public:
02188     GameAPIResizeAOIMessage(const char *name=NULL, int kind=0);
02189     GameAPIResizeAOIMessage(const GameAPIResizeAOIMessage& other);
02190     virtual ~GameAPIResizeAOIMessage();
02191     GameAPIResizeAOIMessage& operator=(const GameAPIResizeAOIMessage& other);
02192     virtual GameAPIResizeAOIMessage *dup() const {return new GameAPIResizeAOIMessage(*this);}
02193     virtual void parsimPack(cCommBuffer *b);
02194     virtual void parsimUnpack(cCommBuffer *b);
02195 
02196     // field getter/setter methods
02197     virtual double getAOIsize() const;
02198     virtual void setAOIsize(double AOIsize_var);
02199 };
02200 
02201 inline void doPacking(cCommBuffer *b, GameAPIResizeAOIMessage& obj) {obj.parsimPack(b);}
02202 inline void doUnpacking(cCommBuffer *b, GameAPIResizeAOIMessage& obj) {obj.parsimUnpack(b);}
02203 
02214 class GameAPIChatMessage : public GameAPIMessage
02215 {
02216   protected:
02217     NodeHandle src_var;
02218     opp_string msg_var;
02219 
02220     // protected and unimplemented operator==(), to prevent accidental usage
02221     bool operator==(const GameAPIChatMessage&);
02222 
02223   public:
02224     GameAPIChatMessage(const char *name=NULL, int kind=0);
02225     GameAPIChatMessage(const GameAPIChatMessage& other);
02226     virtual ~GameAPIChatMessage();
02227     GameAPIChatMessage& operator=(const GameAPIChatMessage& other);
02228     virtual GameAPIChatMessage *dup() const {return new GameAPIChatMessage(*this);}
02229     virtual void parsimPack(cCommBuffer *b);
02230     virtual void parsimUnpack(cCommBuffer *b);
02231 
02232     // field getter/setter methods
02233     virtual NodeHandle& getSrc();
02234     virtual const NodeHandle& getSrc() const {return const_cast<GameAPIChatMessage*>(this)->getSrc();}
02235     virtual void setSrc(const NodeHandle& src_var);
02236     virtual const char * getMsg() const;
02237     virtual void setMsg(const char * msg_var);
02238 };
02239 
02240 inline void doPacking(cCommBuffer *b, GameAPIChatMessage& obj) {obj.parsimPack(b);}
02241 inline void doUnpacking(cCommBuffer *b, GameAPIChatMessage& obj) {obj.parsimUnpack(b);}
02242 
02256 class GameAPISnowMessage : public GameAPIMessage
02257 {
02258   protected:
02259     NodeHandle src_var;
02260     Vector2D start_var;
02261     Vector2D end_var;
02262     int timeSec_var;
02263     int timeUsec_var;
02264 
02265     // protected and unimplemented operator==(), to prevent accidental usage
02266     bool operator==(const GameAPISnowMessage&);
02267 
02268   public:
02269     GameAPISnowMessage(const char *name=NULL, int kind=0);
02270     GameAPISnowMessage(const GameAPISnowMessage& other);
02271     virtual ~GameAPISnowMessage();
02272     GameAPISnowMessage& operator=(const GameAPISnowMessage& other);
02273     virtual GameAPISnowMessage *dup() const {return new GameAPISnowMessage(*this);}
02274     virtual void parsimPack(cCommBuffer *b);
02275     virtual void parsimUnpack(cCommBuffer *b);
02276 
02277     // field getter/setter methods
02278     virtual NodeHandle& getSrc();
02279     virtual const NodeHandle& getSrc() const {return const_cast<GameAPISnowMessage*>(this)->getSrc();}
02280     virtual void setSrc(const NodeHandle& src_var);
02281     virtual Vector2D& getStart();
02282     virtual const Vector2D& getStart() const {return const_cast<GameAPISnowMessage*>(this)->getStart();}
02283     virtual void setStart(const Vector2D& start_var);
02284     virtual Vector2D& getEnd();
02285     virtual const Vector2D& getEnd() const {return const_cast<GameAPISnowMessage*>(this)->getEnd();}
02286     virtual void setEnd(const Vector2D& end_var);
02287     virtual int getTimeSec() const;
02288     virtual void setTimeSec(int timeSec_var);
02289     virtual int getTimeUsec() const;
02290     virtual void setTimeUsec(int timeUsec_var);
02291 };
02292 
02293 inline void doPacking(cCommBuffer *b, GameAPISnowMessage& obj) {obj.parsimPack(b);}
02294 inline void doUnpacking(cCommBuffer *b, GameAPISnowMessage& obj) {obj.parsimUnpack(b);}
02295 
02308 class GameAPIFrozenMessage : public GameAPIMessage
02309 {
02310   protected:
02311     NodeHandle src_var;
02312     int thrower_var;
02313     int timeSec_var;
02314     int timeUsec_var;
02315 
02316     // protected and unimplemented operator==(), to prevent accidental usage
02317     bool operator==(const GameAPIFrozenMessage&);
02318 
02319   public:
02320     GameAPIFrozenMessage(const char *name=NULL, int kind=0);
02321     GameAPIFrozenMessage(const GameAPIFrozenMessage& other);
02322     virtual ~GameAPIFrozenMessage();
02323     GameAPIFrozenMessage& operator=(const GameAPIFrozenMessage& other);
02324     virtual GameAPIFrozenMessage *dup() const {return new GameAPIFrozenMessage(*this);}
02325     virtual void parsimPack(cCommBuffer *b);
02326     virtual void parsimUnpack(cCommBuffer *b);
02327 
02328     // field getter/setter methods
02329     virtual NodeHandle& getSrc();
02330     virtual const NodeHandle& getSrc() const {return const_cast<GameAPIFrozenMessage*>(this)->getSrc();}
02331     virtual void setSrc(const NodeHandle& src_var);
02332     virtual int getThrower() const;
02333     virtual void setThrower(int thrower_var);
02334     virtual int getTimeSec() const;
02335     virtual void setTimeSec(int timeSec_var);
02336     virtual int getTimeUsec() const;
02337     virtual void setTimeUsec(int timeUsec_var);
02338 };
02339 
02340 inline void doPacking(cCommBuffer *b, GameAPIFrozenMessage& obj) {obj.parsimPack(b);}
02341 inline void doUnpacking(cCommBuffer *b, GameAPIFrozenMessage& obj) {obj.parsimUnpack(b);}
02342 
02343 
02344 #endif // _COMMONMESSAGES_M_H_

Generated on Tue Sep 8 17:26:52 2009 for OverSim by  doxygen 1.5.8