CommonMessages_m.h

Go to the documentation of this file.
00001 //
00002 // Generated file, do not edit! Created by opp_msgc 4.1 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 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 <OverlayKey.h>
00018 #include <NodeHandle.h>
00019 #include <IPvXAddress.h>
00020 #include <TransportAddress.h>
00021 #include <BinaryValue.h>
00022 #include <Vector2D.h>
00023 #include <OverSimMessage.h>
00024 
00025 #define KEY_L OverlayKey::getLength()
00026 
00027 static const int TYPE_L = 8;
00028 static const int IPADDR_L = 32;
00029 static const int UDPPORT_L = 16;
00030 static const int HOPCOUNT_L = 16;
00031 static const int NONCE_L = 32;
00032 static const int COMP_L = 16;
00033 static const int NUMSIBLINGS_L = 8;
00034 static const int NUMREDNODES_L = 8;
00035 static const int EXHAUSTIVEFLAG_L = 8;
00036 static const int NEIGHBORSFLAG_L = 8;
00037 static const int RESPONSEFLAG_L = 8;
00038 static const int TRYAGAINFLAG_L = 8;
00039 static const int TIER_L = 8;
00040 static const int ARRAYSIZE_L = 8;
00041 static const int ROUTINGTYPE_L = 8;
00042 static const int SIGNATURE_L = 40*8;
00043 static const int CERT_L = 40*8;
00044 static const int PUBKEY_L = 20*8;
00045 static const int NCSINFO_L = 32;
00046 
00047 #define NODEHANDLE_L (IPADDR_L + UDPPORT_L + KEY_L)
00048 
00049 
00050 #define TRANSPORTADDRESS_L (IPADDR_L + UDPPORT_L)
00051 
00052 #define AUTHBLOCK_L (overlay->getMeasureAuthBlock() ? (SIGNATURE_L + CERT_L + PUBKEY_L) : 0)
00053 
00054 #define BASEOVERLAY_L(msg) TYPE_L
00055 #define BASEROUTE_L(msg) (BASEOVERLAY_L(msg) + NODEHANDLE_L + KEY_L + \
00056                           HOPCOUNT_L + ROUTINGTYPE_L +\
00057                           ARRAYSIZE_L + (msg->getVisitedHopsArraySize() *\
00058                           TRANSPORTADDRESS_L) +\
00059                           ARRAYSIZE_L + (msg->getNextHopsArraySize() *\
00060                           TRANSPORTADDRESS_L) +\
00061                           ARRAYSIZE_L + (msg->getHintsArraySize() *\
00062                           NODEHANDLE_L))
00063 #define BASEAPPDATA_L(msg) (BASEOVERLAY_L(msg) + 2*COMP_L)
00064 #define BASERPC_L(msg) (BASEOVERLAY_L(msg) + NONCE_L + NODEHANDLE_L + \
00065                         TIER_L)
00066 #define BASECALL_L(msg) BASERPC_L(msg)
00067 
00068 #define BASERESPONSE_L(msg) (BASERPC_L(msg) + AUTHBLOCK_L + \
00069                              ((msg->getNcsInfoArraySize()) ? \
00070                               (msg->getNcsInfoArraySize() * NCSINFO_L + 8) : \
00071                               0))
00072 #define FINDNODECALL_L(msg) (BASECALL_L(msg) + KEY_L + NUMSIBLINGS_L + \
00073                              NUMREDNODES_L + EXHAUSTIVEFLAG_L)
00074 
00075 #define FINDNODERESPONSE_L(msg) (BASERESPONSE_L(msg) + NEIGHBORSFLAG_L + \
00076                   (msg->getClosestNodesArraySize() * NODEHANDLE_L))
00077 #define FAILEDNODECALL_L(msg) (BASECALL_L(msg) + IPADDR_L + UDPPORT_L)
00078 #define FAILEDNODERESPONSE_L(msg) (BASERESPONSE_L(msg) + TRYAGAINFLAG_L)
00079 #define PINGCALL_L(msg) BASECALL_L(msg)
00080 #define PINGRESPONSE_L(msg) BASERESPONSE_L(msg)
00081 #define BOOTSTRAPPINGCALL_L(msg) BASECALL_L(msg)
00082 #define BOOTSTRAPPINGRESPONSE_L(msg) BASERESPONSE_L(msg)
00083 #define NEXTHOPCALL_L(msg) BASECALL_L(msg)
00084 #define NEXTHOPRESPONSE_L(msg) BASERESPONSE_L(msg)
00085 // }}
00086 
00087 
00088 
00102 enum BaseOverlayMessageType {
00103     OVERLAYSIGNALING = 0,
00104     RPC = 1,
00105     APPDATA = 2,
00106     OVERLAYROUTE = 3
00107 };
00108 
00125 enum CompType {
00126     INVALID_COMP = 0,
00127     OVERLAY_COMP = 1,
00128     TIER1_COMP = 2,
00129     TIER2_COMP = 3,
00130     TIER3_COMP = 4,
00131     BOOTSTRAPLIST_COMP = 5,
00132     NEIGHBORCACHE_COMP = 6
00133 };
00134 
00152 enum RoutingType {
00153     NO_OVERLAY_ROUTING = 0,
00154     DEFAULT_ROUTING = 1,
00155     ITERATIVE_ROUTING = 2,
00156     EXHAUSTIVE_ITERATIVE_ROUTING = 3,
00157     SEMI_RECURSIVE_ROUTING = 4,
00158     FULL_RECURSIVE_ROUTING = 5,
00159     RECURSIVE_SOURCE_ROUTING = 6,
00160     PROX_AWARE_ITERATIVE_ROUTING = 7
00161 };
00162 
00176 enum TransportType {
00177     INVALID_TRANSPORT = 0,
00178     INTERNAL_TRANSPORT = 1,
00179     UDP_TRANSPORT = 2,
00180     ROUTE_TRANSPORT = 3
00181 };
00182 
00198 enum CommonAPIMessageType {
00199     COMMON_API_UNDEFINED = 0,
00200     KBR_ROUTE = 1,
00201     KBR_DELIVER = 2,
00202     KBR_FORWARD = 3,
00203     KBR_FORWARD_RESPONSE = 4,
00204     KBR_UPDATE = 5
00205 };
00206 
00220 enum StatType {
00221     MAINTENANCE_STAT = 0,
00222     APP_DATA_STAT = 1,
00223     APP_LOOKUP_STAT = 2
00224 };
00225 
00242 enum GameAPIMessageCommand {
00243     MOVEMENT_INDICATION = 0,
00244     MOVEMENT_REQUEST = 1,
00245     NEIGHBOR_UPDATE = 2,
00246     RESIZE_AOI = 3,
00247     GAMEEVENT_CHAT = 4,
00248     GAMEEVENT_SNOW = 5,
00249     GAMEEVENT_FROZEN = 6
00250 };
00251 
00263 class AuthBlock : public ::cObject
00264 {
00265   protected:
00266     ::BinaryValue signature_var;
00267     ::BinaryValue pubKey_var;
00268     ::BinaryValue cert_var;
00269 
00270     // protected and unimplemented operator==(), to prevent accidental usage
00271     bool operator==(const AuthBlock&);
00272 
00273   public:
00274     AuthBlock();
00275     AuthBlock(const AuthBlock& other);
00276     virtual ~AuthBlock();
00277     AuthBlock& operator=(const AuthBlock& other);
00278     virtual AuthBlock *dup() const {return new AuthBlock(*this);}
00279     virtual void parsimPack(cCommBuffer *b);
00280     virtual void parsimUnpack(cCommBuffer *b);
00281 
00282     // field getter/setter methods
00283     virtual BinaryValue& getSignature();
00284     virtual const BinaryValue& getSignature() const {return const_cast<AuthBlock*>(this)->getSignature();}
00285     virtual void setSignature(const BinaryValue& signature_var);
00286     virtual BinaryValue& getPubKey();
00287     virtual const BinaryValue& getPubKey() const {return const_cast<AuthBlock*>(this)->getPubKey();}
00288     virtual void setPubKey(const BinaryValue& pubKey_var);
00289     virtual BinaryValue& getCert();
00290     virtual const BinaryValue& getCert() const {return const_cast<AuthBlock*>(this)->getCert();}
00291     virtual void setCert(const BinaryValue& cert_var);
00292 };
00293 
00294 inline void doPacking(cCommBuffer *b, AuthBlock& obj) {obj.parsimPack(b);}
00295 inline void doUnpacking(cCommBuffer *b, AuthBlock& obj) {obj.parsimUnpack(b);}
00296 
00307 class BaseOverlayMessage : public ::OverSimMessage
00308 {
00309   protected:
00310     int type_var;
00311     int statType_var;
00312 
00313     // protected and unimplemented operator==(), to prevent accidental usage
00314     bool operator==(const BaseOverlayMessage&);
00315 
00316   public:
00317     BaseOverlayMessage(const char *name=NULL, int kind=0);
00318     BaseOverlayMessage(const BaseOverlayMessage& other);
00319     virtual ~BaseOverlayMessage();
00320     BaseOverlayMessage& operator=(const BaseOverlayMessage& other);
00321     virtual BaseOverlayMessage *dup() const {return new BaseOverlayMessage(*this);}
00322     virtual void parsimPack(cCommBuffer *b);
00323     virtual void parsimUnpack(cCommBuffer *b);
00324 
00325     // field getter/setter methods
00326     virtual int getType() const;
00327     virtual void setType(int type_var);
00328     virtual int getStatType() const;
00329     virtual void setStatType(int statType_var);
00330 };
00331 
00332 inline void doPacking(cCommBuffer *b, BaseOverlayMessage& obj) {obj.parsimPack(b);}
00333 inline void doUnpacking(cCommBuffer *b, BaseOverlayMessage& obj) {obj.parsimUnpack(b);}
00334 
00352 class BaseRouteMessage : public ::BaseOverlayMessage
00353 {
00354   protected:
00355     ::OverlayKey destKey_var;
00356     ::NodeHandle srcNode_var;
00357     int routingType_var;
00358     int hopCount_var;
00359     ::TransportAddress *visitedHops_var; // array ptr
00360     unsigned int visitedHops_arraysize;
00361     ::TransportAddress *nextHops_var; // array ptr
00362     unsigned int nextHops_arraysize;
00363     ::NodeHandle *hints_var; // array ptr
00364     unsigned int hints_arraysize;
00365     simtime_t hopStamp_var;
00366     simtime_t *hopDelay_var; // array ptr
00367     unsigned int hopDelay_arraysize;
00368 
00369     // protected and unimplemented operator==(), to prevent accidental usage
00370     bool operator==(const BaseRouteMessage&);
00371 
00372   public:
00373     BaseRouteMessage(const char *name=NULL, int kind=0);
00374     BaseRouteMessage(const BaseRouteMessage& other);
00375     virtual ~BaseRouteMessage();
00376     BaseRouteMessage& operator=(const BaseRouteMessage& other);
00377     virtual BaseRouteMessage *dup() const {return new BaseRouteMessage(*this);}
00378     virtual void parsimPack(cCommBuffer *b);
00379     virtual void parsimUnpack(cCommBuffer *b);
00380 
00381     // field getter/setter methods
00382     virtual OverlayKey& getDestKey();
00383     virtual const OverlayKey& getDestKey() const {return const_cast<BaseRouteMessage*>(this)->getDestKey();}
00384     virtual void setDestKey(const OverlayKey& destKey_var);
00385     virtual NodeHandle& getSrcNode();
00386     virtual const NodeHandle& getSrcNode() const {return const_cast<BaseRouteMessage*>(this)->getSrcNode();}
00387     virtual void setSrcNode(const NodeHandle& srcNode_var);
00388     virtual int getRoutingType() const;
00389     virtual void setRoutingType(int routingType_var);
00390     virtual int getHopCount() const;
00391     virtual void setHopCount(int hopCount_var);
00392     virtual void setVisitedHopsArraySize(unsigned int size);
00393     virtual unsigned int getVisitedHopsArraySize() const;
00394     virtual TransportAddress& getVisitedHops(unsigned int k);
00395     virtual const TransportAddress& getVisitedHops(unsigned int k) const {return const_cast<BaseRouteMessage*>(this)->getVisitedHops(k);}
00396     virtual void setVisitedHops(unsigned int k, const TransportAddress& visitedHops_var);
00397     virtual void setNextHopsArraySize(unsigned int size);
00398     virtual unsigned int getNextHopsArraySize() const;
00399     virtual TransportAddress& getNextHops(unsigned int k);
00400     virtual const TransportAddress& getNextHops(unsigned int k) const {return const_cast<BaseRouteMessage*>(this)->getNextHops(k);}
00401     virtual void setNextHops(unsigned int k, const TransportAddress& nextHops_var);
00402     virtual void setHintsArraySize(unsigned int size);
00403     virtual unsigned int getHintsArraySize() const;
00404     virtual NodeHandle& getHints(unsigned int k);
00405     virtual const NodeHandle& getHints(unsigned int k) const {return const_cast<BaseRouteMessage*>(this)->getHints(k);}
00406     virtual void setHints(unsigned int k, const NodeHandle& hints_var);
00407     virtual simtime_t getHopStamp() const;
00408     virtual void setHopStamp(simtime_t hopStamp_var);
00409     virtual void setHopDelayArraySize(unsigned int size);
00410     virtual unsigned int getHopDelayArraySize() const;
00411     virtual simtime_t getHopDelay(unsigned int k) const;
00412     virtual void setHopDelay(unsigned int k, simtime_t hopDelay_var);
00413 };
00414 
00415 inline void doPacking(cCommBuffer *b, BaseRouteMessage& obj) {obj.parsimPack(b);}
00416 inline void doUnpacking(cCommBuffer *b, BaseRouteMessage& obj) {obj.parsimUnpack(b);}
00417 
00428 class BaseAppDataMessage : public ::BaseOverlayMessage
00429 {
00430   protected:
00431     int destComp_var;
00432     int srcComp_var;
00433 
00434     // protected and unimplemented operator==(), to prevent accidental usage
00435     bool operator==(const BaseAppDataMessage&);
00436 
00437   public:
00438     BaseAppDataMessage(const char *name=NULL, int kind=0);
00439     BaseAppDataMessage(const BaseAppDataMessage& other);
00440     virtual ~BaseAppDataMessage();
00441     BaseAppDataMessage& operator=(const BaseAppDataMessage& other);
00442     virtual BaseAppDataMessage *dup() const {return new BaseAppDataMessage(*this);}
00443     virtual void parsimPack(cCommBuffer *b);
00444     virtual void parsimUnpack(cCommBuffer *b);
00445 
00446     // field getter/setter methods
00447     virtual int getDestComp() const;
00448     virtual void setDestComp(int destComp_var);
00449     virtual int getSrcComp() const;
00450     virtual void setSrcComp(int srcComp_var);
00451 };
00452 
00453 inline void doPacking(cCommBuffer *b, BaseAppDataMessage& obj) {obj.parsimPack(b);}
00454 inline void doUnpacking(cCommBuffer *b, BaseAppDataMessage& obj) {obj.parsimUnpack(b);}
00455 
00467 class BaseRpcMessage : public ::BaseOverlayMessage
00468 {
00469   protected:
00470     unsigned int nonce_var;
00471     ::NodeHandle srcNode_var;
00472     ::AuthBlock *authBlock_var; // array ptr
00473     uint8_t authBlock_arraysize;
00474 
00475     // protected and unimplemented operator==(), to prevent accidental usage
00476     bool operator==(const BaseRpcMessage&);
00477 
00478   public:
00479     BaseRpcMessage(const char *name=NULL, int kind=0);
00480     BaseRpcMessage(const BaseRpcMessage& other);
00481     virtual ~BaseRpcMessage();
00482     BaseRpcMessage& operator=(const BaseRpcMessage& other);
00483     virtual BaseRpcMessage *dup() const {return new BaseRpcMessage(*this);}
00484     virtual void parsimPack(cCommBuffer *b);
00485     virtual void parsimUnpack(cCommBuffer *b);
00486 
00487     // field getter/setter methods
00488     virtual unsigned int getNonce() const;
00489     virtual void setNonce(unsigned int nonce_var);
00490     virtual NodeHandle& getSrcNode();
00491     virtual const NodeHandle& getSrcNode() const {return const_cast<BaseRpcMessage*>(this)->getSrcNode();}
00492     virtual void setSrcNode(const NodeHandle& srcNode_var);
00493     virtual void setAuthBlockArraySize(uint8_t size);
00494     virtual uint8_t getAuthBlockArraySize() const;
00495     virtual AuthBlock& getAuthBlock(uint8_t k);
00496     virtual const AuthBlock& getAuthBlock(uint8_t k) const {return const_cast<BaseRpcMessage*>(this)->getAuthBlock(k);}
00497     virtual void setAuthBlock(uint8_t k, const AuthBlock& authBlock_var);
00498 };
00499 
00500 inline void doPacking(cCommBuffer *b, BaseRpcMessage& obj) {obj.parsimPack(b);}
00501 inline void doUnpacking(cCommBuffer *b, BaseRpcMessage& obj) {obj.parsimUnpack(b);}
00502 
00511 class BaseCallMessage : public ::BaseRpcMessage
00512 {
00513   protected:
00514 
00515     // protected and unimplemented operator==(), to prevent accidental usage
00516     bool operator==(const BaseCallMessage&);
00517 
00518   public:
00519     BaseCallMessage(const char *name=NULL, int kind=0);
00520     BaseCallMessage(const BaseCallMessage& other);
00521     virtual ~BaseCallMessage();
00522     BaseCallMessage& operator=(const BaseCallMessage& other);
00523     virtual BaseCallMessage *dup() const {return new BaseCallMessage(*this);}
00524     virtual void parsimPack(cCommBuffer *b);
00525     virtual void parsimUnpack(cCommBuffer *b);
00526 
00527     // field getter/setter methods
00528 };
00529 
00530 inline void doPacking(cCommBuffer *b, BaseCallMessage& obj) {obj.parsimPack(b);}
00531 inline void doUnpacking(cCommBuffer *b, BaseCallMessage& obj) {obj.parsimUnpack(b);}
00532 
00543 class BaseResponseMessage : public ::BaseRpcMessage
00544 {
00545   protected:
00546     int callHopCount_var;
00547     double *ncsInfo_var; // array ptr
00548     unsigned int ncsInfo_arraysize;
00549 
00550     // protected and unimplemented operator==(), to prevent accidental usage
00551     bool operator==(const BaseResponseMessage&);
00552 
00553   public:
00554     BaseResponseMessage(const char *name=NULL, int kind=0);
00555     BaseResponseMessage(const BaseResponseMessage& other);
00556     virtual ~BaseResponseMessage();
00557     BaseResponseMessage& operator=(const BaseResponseMessage& other);
00558     virtual BaseResponseMessage *dup() const {return new BaseResponseMessage(*this);}
00559     virtual void parsimPack(cCommBuffer *b);
00560     virtual void parsimUnpack(cCommBuffer *b);
00561 
00562     // field getter/setter methods
00563     virtual int getCallHopCount() const;
00564     virtual void setCallHopCount(int callHopCount_var);
00565     virtual void setNcsInfoArraySize(unsigned int size);
00566     virtual unsigned int getNcsInfoArraySize() const;
00567     virtual double getNcsInfo(unsigned int k) const;
00568     virtual void setNcsInfo(unsigned int k, double ncsInfo_var);
00569 };
00570 
00571 inline void doPacking(cCommBuffer *b, BaseResponseMessage& obj) {obj.parsimPack(b);}
00572 inline void doUnpacking(cCommBuffer *b, BaseResponseMessage& obj) {obj.parsimUnpack(b);}
00573 
00582 class RpcTimeoutMessage : public ::BaseRpcMessage
00583 {
00584   protected:
00585 
00586     // protected and unimplemented operator==(), to prevent accidental usage
00587     bool operator==(const RpcTimeoutMessage&);
00588 
00589   public:
00590     RpcTimeoutMessage(const char *name=NULL, int kind=0);
00591     RpcTimeoutMessage(const RpcTimeoutMessage& other);
00592     virtual ~RpcTimeoutMessage();
00593     RpcTimeoutMessage& operator=(const RpcTimeoutMessage& other);
00594     virtual RpcTimeoutMessage *dup() const {return new RpcTimeoutMessage(*this);}
00595     virtual void parsimPack(cCommBuffer *b);
00596     virtual void parsimUnpack(cCommBuffer *b);
00597 
00598     // field getter/setter methods
00599 };
00600 
00601 inline void doPacking(cCommBuffer *b, RpcTimeoutMessage& obj) {obj.parsimPack(b);}
00602 inline void doUnpacking(cCommBuffer *b, RpcTimeoutMessage& obj) {obj.parsimUnpack(b);}
00603 
00616 class FindNodeCall : public ::BaseCallMessage
00617 {
00618   protected:
00619     ::OverlayKey lookupKey_var;
00620     int numRedundantNodes_var;
00621     int numSiblings_var;
00622     bool exhaustiveIterative_var;
00623 
00624     // protected and unimplemented operator==(), to prevent accidental usage
00625     bool operator==(const FindNodeCall&);
00626 
00627   public:
00628     FindNodeCall(const char *name=NULL, int kind=0);
00629     FindNodeCall(const FindNodeCall& other);
00630     virtual ~FindNodeCall();
00631     FindNodeCall& operator=(const FindNodeCall& other);
00632     virtual FindNodeCall *dup() const {return new FindNodeCall(*this);}
00633     virtual void parsimPack(cCommBuffer *b);
00634     virtual void parsimUnpack(cCommBuffer *b);
00635 
00636     // field getter/setter methods
00637     virtual OverlayKey& getLookupKey();
00638     virtual const OverlayKey& getLookupKey() const {return const_cast<FindNodeCall*>(this)->getLookupKey();}
00639     virtual void setLookupKey(const OverlayKey& lookupKey_var);
00640     virtual int getNumRedundantNodes() const;
00641     virtual void setNumRedundantNodes(int numRedundantNodes_var);
00642     virtual int getNumSiblings() const;
00643     virtual void setNumSiblings(int numSiblings_var);
00644     virtual bool getExhaustiveIterative() const;
00645     virtual void setExhaustiveIterative(bool exhaustiveIterative_var);
00646 };
00647 
00648 inline void doPacking(cCommBuffer *b, FindNodeCall& obj) {obj.parsimPack(b);}
00649 inline void doUnpacking(cCommBuffer *b, FindNodeCall& obj) {obj.parsimUnpack(b);}
00650 
00662 class FindNodeResponse : public ::BaseResponseMessage
00663 {
00664   protected:
00665     bool siblings_var;
00666     ::NodeHandle *closestNodes_var; // array ptr
00667     unsigned int closestNodes_arraysize;
00668 
00669     // protected and unimplemented operator==(), to prevent accidental usage
00670     bool operator==(const FindNodeResponse&);
00671 
00672   public:
00673     FindNodeResponse(const char *name=NULL, int kind=0);
00674     FindNodeResponse(const FindNodeResponse& other);
00675     virtual ~FindNodeResponse();
00676     FindNodeResponse& operator=(const FindNodeResponse& other);
00677     virtual FindNodeResponse *dup() const {return new FindNodeResponse(*this);}
00678     virtual void parsimPack(cCommBuffer *b);
00679     virtual void parsimUnpack(cCommBuffer *b);
00680 
00681     // field getter/setter methods
00682     virtual bool getSiblings() const;
00683     virtual void setSiblings(bool siblings_var);
00684     virtual void setClosestNodesArraySize(unsigned int size);
00685     virtual unsigned int getClosestNodesArraySize() const;
00686     virtual NodeHandle& getClosestNodes(unsigned int k);
00687     virtual const NodeHandle& getClosestNodes(unsigned int k) const {return const_cast<FindNodeResponse*>(this)->getClosestNodes(k);}
00688     virtual void setClosestNodes(unsigned int k, const NodeHandle& closestNodes_var);
00689 };
00690 
00691 inline void doPacking(cCommBuffer *b, FindNodeResponse& obj) {obj.parsimPack(b);}
00692 inline void doUnpacking(cCommBuffer *b, FindNodeResponse& obj) {obj.parsimUnpack(b);}
00693 
00703 class FailedNodeCall : public ::BaseCallMessage
00704 {
00705   protected:
00706     ::TransportAddress failedNode_var;
00707 
00708     // protected and unimplemented operator==(), to prevent accidental usage
00709     bool operator==(const FailedNodeCall&);
00710 
00711   public:
00712     FailedNodeCall(const char *name=NULL, int kind=0);
00713     FailedNodeCall(const FailedNodeCall& other);
00714     virtual ~FailedNodeCall();
00715     FailedNodeCall& operator=(const FailedNodeCall& other);
00716     virtual FailedNodeCall *dup() const {return new FailedNodeCall(*this);}
00717     virtual void parsimPack(cCommBuffer *b);
00718     virtual void parsimUnpack(cCommBuffer *b);
00719 
00720     // field getter/setter methods
00721     virtual TransportAddress& getFailedNode();
00722     virtual const TransportAddress& getFailedNode() const {return const_cast<FailedNodeCall*>(this)->getFailedNode();}
00723     virtual void setFailedNode(const TransportAddress& failedNode_var);
00724 };
00725 
00726 inline void doPacking(cCommBuffer *b, FailedNodeCall& obj) {obj.parsimPack(b);}
00727 inline void doUnpacking(cCommBuffer *b, FailedNodeCall& obj) {obj.parsimUnpack(b);}
00728 
00738 class FailedNodeResponse : public ::BaseResponseMessage
00739 {
00740   protected:
00741     bool tryAgain_var;
00742 
00743     // protected and unimplemented operator==(), to prevent accidental usage
00744     bool operator==(const FailedNodeResponse&);
00745 
00746   public:
00747     FailedNodeResponse(const char *name=NULL, int kind=0);
00748     FailedNodeResponse(const FailedNodeResponse& other);
00749     virtual ~FailedNodeResponse();
00750     FailedNodeResponse& operator=(const FailedNodeResponse& other);
00751     virtual FailedNodeResponse *dup() const {return new FailedNodeResponse(*this);}
00752     virtual void parsimPack(cCommBuffer *b);
00753     virtual void parsimUnpack(cCommBuffer *b);
00754 
00755     // field getter/setter methods
00756     virtual bool getTryAgain() const;
00757     virtual void setTryAgain(bool tryAgain_var);
00758 };
00759 
00760 inline void doPacking(cCommBuffer *b, FailedNodeResponse& obj) {obj.parsimPack(b);}
00761 inline void doUnpacking(cCommBuffer *b, FailedNodeResponse& obj) {obj.parsimUnpack(b);}
00762 
00771 class PingCall : public ::BaseCallMessage
00772 {
00773   protected:
00774 
00775     // protected and unimplemented operator==(), to prevent accidental usage
00776     bool operator==(const PingCall&);
00777 
00778   public:
00779     PingCall(const char *name=NULL, int kind=0);
00780     PingCall(const PingCall& other);
00781     virtual ~PingCall();
00782     PingCall& operator=(const PingCall& other);
00783     virtual PingCall *dup() const {return new PingCall(*this);}
00784     virtual void parsimPack(cCommBuffer *b);
00785     virtual void parsimUnpack(cCommBuffer *b);
00786 
00787     // field getter/setter methods
00788 };
00789 
00790 inline void doPacking(cCommBuffer *b, PingCall& obj) {obj.parsimPack(b);}
00791 inline void doUnpacking(cCommBuffer *b, PingCall& obj) {obj.parsimUnpack(b);}
00792 
00801 class PingResponse : public ::BaseResponseMessage
00802 {
00803   protected:
00804 
00805     // protected and unimplemented operator==(), to prevent accidental usage
00806     bool operator==(const PingResponse&);
00807 
00808   public:
00809     PingResponse(const char *name=NULL, int kind=0);
00810     PingResponse(const PingResponse& other);
00811     virtual ~PingResponse();
00812     PingResponse& operator=(const PingResponse& other);
00813     virtual PingResponse *dup() const {return new PingResponse(*this);}
00814     virtual void parsimPack(cCommBuffer *b);
00815     virtual void parsimUnpack(cCommBuffer *b);
00816 
00817     // field getter/setter methods
00818 };
00819 
00820 inline void doPacking(cCommBuffer *b, PingResponse& obj) {obj.parsimPack(b);}
00821 inline void doUnpacking(cCommBuffer *b, PingResponse& obj) {obj.parsimUnpack(b);}
00822 
00833 class CompReadyMessage : public ::cPacket
00834 {
00835   protected:
00836     bool ready_var;
00837     int comp_var;
00838 
00839     // protected and unimplemented operator==(), to prevent accidental usage
00840     bool operator==(const CompReadyMessage&);
00841 
00842   public:
00843     CompReadyMessage(const char *name=NULL, int kind=0);
00844     CompReadyMessage(const CompReadyMessage& other);
00845     virtual ~CompReadyMessage();
00846     CompReadyMessage& operator=(const CompReadyMessage& other);
00847     virtual CompReadyMessage *dup() const {return new CompReadyMessage(*this);}
00848     virtual void parsimPack(cCommBuffer *b);
00849     virtual void parsimUnpack(cCommBuffer *b);
00850 
00851     // field getter/setter methods
00852     virtual bool getReady() const;
00853     virtual void setReady(bool ready_var);
00854     virtual int getComp() const;
00855     virtual void setComp(int comp_var);
00856 };
00857 
00858 inline void doPacking(cCommBuffer *b, CompReadyMessage& obj) {obj.parsimPack(b);}
00859 inline void doUnpacking(cCommBuffer *b, CompReadyMessage& obj) {obj.parsimUnpack(b);}
00860 
00869 class BootstrapLookupMessage : public ::BaseOverlayMessage
00870 {
00871   protected:
00872 
00873     // protected and unimplemented operator==(), to prevent accidental usage
00874     bool operator==(const BootstrapLookupMessage&);
00875 
00876   public:
00877     BootstrapLookupMessage(const char *name=NULL, int kind=0);
00878     BootstrapLookupMessage(const BootstrapLookupMessage& other);
00879     virtual ~BootstrapLookupMessage();
00880     BootstrapLookupMessage& operator=(const BootstrapLookupMessage& other);
00881     virtual BootstrapLookupMessage *dup() const {return new BootstrapLookupMessage(*this);}
00882     virtual void parsimPack(cCommBuffer *b);
00883     virtual void parsimUnpack(cCommBuffer *b);
00884 
00885     // field getter/setter methods
00886 };
00887 
00888 inline void doPacking(cCommBuffer *b, BootstrapLookupMessage& obj) {obj.parsimPack(b);}
00889 inline void doUnpacking(cCommBuffer *b, BootstrapLookupMessage& obj) {obj.parsimUnpack(b);}
00890 
00899 class NextHopCall : public ::BaseCallMessage
00900 {
00901   protected:
00902 
00903     // protected and unimplemented operator==(), to prevent accidental usage
00904     bool operator==(const NextHopCall&);
00905 
00906   public:
00907     NextHopCall(const char *name=NULL, int kind=0);
00908     NextHopCall(const NextHopCall& other);
00909     virtual ~NextHopCall();
00910     NextHopCall& operator=(const NextHopCall& other);
00911     virtual NextHopCall *dup() const {return new NextHopCall(*this);}
00912     virtual void parsimPack(cCommBuffer *b);
00913     virtual void parsimUnpack(cCommBuffer *b);
00914 
00915     // field getter/setter methods
00916 };
00917 
00918 inline void doPacking(cCommBuffer *b, NextHopCall& obj) {obj.parsimPack(b);}
00919 inline void doUnpacking(cCommBuffer *b, NextHopCall& obj) {obj.parsimUnpack(b);}
00920 
00929 class NextHopResponse : public ::BaseResponseMessage
00930 {
00931   protected:
00932 
00933     // protected and unimplemented operator==(), to prevent accidental usage
00934     bool operator==(const NextHopResponse&);
00935 
00936   public:
00937     NextHopResponse(const char *name=NULL, int kind=0);
00938     NextHopResponse(const NextHopResponse& other);
00939     virtual ~NextHopResponse();
00940     NextHopResponse& operator=(const NextHopResponse& other);
00941     virtual NextHopResponse *dup() const {return new NextHopResponse(*this);}
00942     virtual void parsimPack(cCommBuffer *b);
00943     virtual void parsimUnpack(cCommBuffer *b);
00944 
00945     // field getter/setter methods
00946 };
00947 
00948 inline void doPacking(cCommBuffer *b, NextHopResponse& obj) {obj.parsimPack(b);}
00949 inline void doUnpacking(cCommBuffer *b, NextHopResponse& obj) {obj.parsimUnpack(b);}
00950 
00960 class CommonAPIMessage : public ::cPacket
00961 {
00962   protected:
00963     int type_var;
00964 
00965     // protected and unimplemented operator==(), to prevent accidental usage
00966     bool operator==(const CommonAPIMessage&);
00967 
00968   public:
00969     CommonAPIMessage(const char *name=NULL, int kind=0);
00970     CommonAPIMessage(const CommonAPIMessage& other);
00971     virtual ~CommonAPIMessage();
00972     CommonAPIMessage& operator=(const CommonAPIMessage& other);
00973     virtual CommonAPIMessage *dup() const {return new CommonAPIMessage(*this);}
00974     virtual void parsimPack(cCommBuffer *b);
00975     virtual void parsimUnpack(cCommBuffer *b);
00976 
00977     // field getter/setter methods
00978     virtual int getType() const;
00979     virtual void setType(int type_var);
00980 };
00981 
00982 inline void doPacking(cCommBuffer *b, CommonAPIMessage& obj) {obj.parsimPack(b);}
00983 inline void doUnpacking(cCommBuffer *b, CommonAPIMessage& obj) {obj.parsimUnpack(b);}
00984 
00998 class KBRroute : public ::CommonAPIMessage
00999 {
01000   protected:
01001     ::OverlayKey destKey_var;
01002     int destComp_var;
01003     int srcComp_var;
01004     ::TransportAddress *sourceRoute_var; // array ptr
01005     unsigned int sourceRoute_arraysize;
01006     int routingType_var;
01007 
01008     // protected and unimplemented operator==(), to prevent accidental usage
01009     bool operator==(const KBRroute&);
01010 
01011   public:
01012     KBRroute(const char *name=NULL, int kind=0);
01013     KBRroute(const KBRroute& other);
01014     virtual ~KBRroute();
01015     KBRroute& operator=(const KBRroute& other);
01016     virtual KBRroute *dup() const {return new KBRroute(*this);}
01017     virtual void parsimPack(cCommBuffer *b);
01018     virtual void parsimUnpack(cCommBuffer *b);
01019 
01020     // field getter/setter methods
01021     virtual OverlayKey& getDestKey();
01022     virtual const OverlayKey& getDestKey() const {return const_cast<KBRroute*>(this)->getDestKey();}
01023     virtual void setDestKey(const OverlayKey& destKey_var);
01024     virtual int getDestComp() const;
01025     virtual void setDestComp(int destComp_var);
01026     virtual int getSrcComp() const;
01027     virtual void setSrcComp(int srcComp_var);
01028     virtual void setSourceRouteArraySize(unsigned int size);
01029     virtual unsigned int getSourceRouteArraySize() const;
01030     virtual TransportAddress& getSourceRoute(unsigned int k);
01031     virtual const TransportAddress& getSourceRoute(unsigned int k) const {return const_cast<KBRroute*>(this)->getSourceRoute(k);}
01032     virtual void setSourceRoute(unsigned int k, const TransportAddress& sourceRoute_var);
01033     virtual int getRoutingType() const;
01034     virtual void setRoutingType(int routingType_var);
01035 };
01036 
01037 inline void doPacking(cCommBuffer *b, KBRroute& obj) {obj.parsimPack(b);}
01038 inline void doUnpacking(cCommBuffer *b, KBRroute& obj) {obj.parsimUnpack(b);}
01039 
01050 class KBRforward : public ::CommonAPIMessage
01051 {
01052   protected:
01053     ::OverlayKey destKey_var;
01054     ::NodeHandle nextHopNode_var;
01055 
01056     // protected and unimplemented operator==(), to prevent accidental usage
01057     bool operator==(const KBRforward&);
01058 
01059   public:
01060     KBRforward(const char *name=NULL, int kind=0);
01061     KBRforward(const KBRforward& other);
01062     virtual ~KBRforward();
01063     KBRforward& operator=(const KBRforward& other);
01064     virtual KBRforward *dup() const {return new KBRforward(*this);}
01065     virtual void parsimPack(cCommBuffer *b);
01066     virtual void parsimUnpack(cCommBuffer *b);
01067 
01068     // field getter/setter methods
01069     virtual OverlayKey& getDestKey();
01070     virtual const OverlayKey& getDestKey() const {return const_cast<KBRforward*>(this)->getDestKey();}
01071     virtual void setDestKey(const OverlayKey& destKey_var);
01072     virtual NodeHandle& getNextHopNode();
01073     virtual const NodeHandle& getNextHopNode() const {return const_cast<KBRforward*>(this)->getNextHopNode();}
01074     virtual void setNextHopNode(const NodeHandle& nextHopNode_var);
01075 };
01076 
01077 inline void doPacking(cCommBuffer *b, KBRforward& obj) {obj.parsimPack(b);}
01078 inline void doUnpacking(cCommBuffer *b, KBRforward& obj) {obj.parsimUnpack(b);}
01079 
01089 class KBRdeliver : public ::CommonAPIMessage
01090 {
01091   protected:
01092     ::OverlayKey destKey_var;
01093 
01094     // protected and unimplemented operator==(), to prevent accidental usage
01095     bool operator==(const KBRdeliver&);
01096 
01097   public:
01098     KBRdeliver(const char *name=NULL, int kind=0);
01099     KBRdeliver(const KBRdeliver& other);
01100     virtual ~KBRdeliver();
01101     KBRdeliver& operator=(const KBRdeliver& other);
01102     virtual KBRdeliver *dup() const {return new KBRdeliver(*this);}
01103     virtual void parsimPack(cCommBuffer *b);
01104     virtual void parsimUnpack(cCommBuffer *b);
01105 
01106     // field getter/setter methods
01107     virtual OverlayKey& getDestKey();
01108     virtual const OverlayKey& getDestKey() const {return const_cast<KBRdeliver*>(this)->getDestKey();}
01109     virtual void setDestKey(const OverlayKey& destKey_var);
01110 };
01111 
01112 inline void doPacking(cCommBuffer *b, KBRdeliver& obj) {obj.parsimPack(b);}
01113 inline void doUnpacking(cCommBuffer *b, KBRdeliver& obj) {obj.parsimUnpack(b);}
01114 
01125 class KBRupdate : public ::CommonAPIMessage
01126 {
01127   protected:
01128     ::NodeHandle node_var;
01129     bool joined_var;
01130 
01131     // protected and unimplemented operator==(), to prevent accidental usage
01132     bool operator==(const KBRupdate&);
01133 
01134   public:
01135     KBRupdate(const char *name=NULL, int kind=0);
01136     KBRupdate(const KBRupdate& other);
01137     virtual ~KBRupdate();
01138     KBRupdate& operator=(const KBRupdate& other);
01139     virtual KBRupdate *dup() const {return new KBRupdate(*this);}
01140     virtual void parsimPack(cCommBuffer *b);
01141     virtual void parsimUnpack(cCommBuffer *b);
01142 
01143     // field getter/setter methods
01144     virtual NodeHandle& getNode();
01145     virtual const NodeHandle& getNode() const {return const_cast<KBRupdate*>(this)->getNode();}
01146     virtual void setNode(const NodeHandle& node_var);
01147     virtual bool getJoined() const;
01148     virtual void setJoined(bool joined_var);
01149 };
01150 
01151 inline void doPacking(cCommBuffer *b, KBRupdate& obj) {obj.parsimPack(b);}
01152 inline void doUnpacking(cCommBuffer *b, KBRupdate& obj) {obj.parsimUnpack(b);}
01153 
01170 class DhtDumpEntry : public ::cObject
01171 {
01172   protected:
01173     ::OverlayKey key_var;
01174     uint32_t kind_var;
01175     uint32_t id_var;
01176     ::BinaryValue value_var;
01177     int ttl_var;
01178     ::NodeHandle ownerNode_var;
01179     bool is_modifiable_var;
01180     bool responsible_var;
01181 
01182     // protected and unimplemented operator==(), to prevent accidental usage
01183     bool operator==(const DhtDumpEntry&);
01184 
01185   public:
01186     DhtDumpEntry();
01187     DhtDumpEntry(const DhtDumpEntry& other);
01188     virtual ~DhtDumpEntry();
01189     DhtDumpEntry& operator=(const DhtDumpEntry& other);
01190     virtual DhtDumpEntry *dup() const {return new DhtDumpEntry(*this);}
01191     virtual void parsimPack(cCommBuffer *b);
01192     virtual void parsimUnpack(cCommBuffer *b);
01193 
01194     // field getter/setter methods
01195     virtual OverlayKey& getKey();
01196     virtual const OverlayKey& getKey() const {return const_cast<DhtDumpEntry*>(this)->getKey();}
01197     virtual void setKey(const OverlayKey& key_var);
01198     virtual uint32_t getKind() const;
01199     virtual void setKind(uint32_t kind_var);
01200     virtual uint32_t getId() const;
01201     virtual void setId(uint32_t id_var);
01202     virtual BinaryValue& getValue();
01203     virtual const BinaryValue& getValue() const {return const_cast<DhtDumpEntry*>(this)->getValue();}
01204     virtual void setValue(const BinaryValue& value_var);
01205     virtual int getTtl() const;
01206     virtual void setTtl(int ttl_var);
01207     virtual NodeHandle& getOwnerNode();
01208     virtual const NodeHandle& getOwnerNode() const {return const_cast<DhtDumpEntry*>(this)->getOwnerNode();}
01209     virtual void setOwnerNode(const NodeHandle& ownerNode_var);
01210     virtual bool getIs_modifiable() const;
01211     virtual void setIs_modifiable(bool is_modifiable_var);
01212     virtual bool getResponsible() const;
01213     virtual void setResponsible(bool responsible_var);
01214 };
01215 
01216 inline void doPacking(cCommBuffer *b, DhtDumpEntry& obj) {obj.parsimPack(b);}
01217 inline void doUnpacking(cCommBuffer *b, DhtDumpEntry& obj) {obj.parsimUnpack(b);}
01218 
01233 class DHTputCAPICall : public ::BaseCallMessage
01234 {
01235   protected:
01236     ::OverlayKey key_var;
01237     uint32_t kind_var;
01238     uint32_t id_var;
01239     ::BinaryValue value_var;
01240     int ttl_var;
01241     bool isModifiable_var;
01242 
01243     // protected and unimplemented operator==(), to prevent accidental usage
01244     bool operator==(const DHTputCAPICall&);
01245 
01246   public:
01247     DHTputCAPICall(const char *name=NULL, int kind=0);
01248     DHTputCAPICall(const DHTputCAPICall& other);
01249     virtual ~DHTputCAPICall();
01250     DHTputCAPICall& operator=(const DHTputCAPICall& other);
01251     virtual DHTputCAPICall *dup() const {return new DHTputCAPICall(*this);}
01252     virtual void parsimPack(cCommBuffer *b);
01253     virtual void parsimUnpack(cCommBuffer *b);
01254 
01255     // field getter/setter methods
01256     virtual OverlayKey& getKey();
01257     virtual const OverlayKey& getKey() const {return const_cast<DHTputCAPICall*>(this)->getKey();}
01258     virtual void setKey(const OverlayKey& key_var);
01259     virtual uint32_t getKind() const;
01260     virtual void setKind(uint32_t kind_var);
01261     virtual uint32_t getId() const;
01262     virtual void setId(uint32_t id_var);
01263     virtual BinaryValue& getValue();
01264     virtual const BinaryValue& getValue() const {return const_cast<DHTputCAPICall*>(this)->getValue();}
01265     virtual void setValue(const BinaryValue& value_var);
01266     virtual int getTtl() const;
01267     virtual void setTtl(int ttl_var);
01268     virtual bool getIsModifiable() const;
01269     virtual void setIsModifiable(bool isModifiable_var);
01270 };
01271 
01272 inline void doPacking(cCommBuffer *b, DHTputCAPICall& obj) {obj.parsimPack(b);}
01273 inline void doUnpacking(cCommBuffer *b, DHTputCAPICall& obj) {obj.parsimUnpack(b);}
01274 
01286 class DHTgetCAPICall : public ::BaseCallMessage
01287 {
01288   protected:
01289     ::OverlayKey key_var;
01290     uint32_t kind_var;
01291     uint32_t id_var;
01292 
01293     // protected and unimplemented operator==(), to prevent accidental usage
01294     bool operator==(const DHTgetCAPICall&);
01295 
01296   public:
01297     DHTgetCAPICall(const char *name=NULL, int kind=0);
01298     DHTgetCAPICall(const DHTgetCAPICall& other);
01299     virtual ~DHTgetCAPICall();
01300     DHTgetCAPICall& operator=(const DHTgetCAPICall& other);
01301     virtual DHTgetCAPICall *dup() const {return new DHTgetCAPICall(*this);}
01302     virtual void parsimPack(cCommBuffer *b);
01303     virtual void parsimUnpack(cCommBuffer *b);
01304 
01305     // field getter/setter methods
01306     virtual OverlayKey& getKey();
01307     virtual const OverlayKey& getKey() const {return const_cast<DHTgetCAPICall*>(this)->getKey();}
01308     virtual void setKey(const OverlayKey& key_var);
01309     virtual uint32_t getKind() const;
01310     virtual void setKind(uint32_t kind_var);
01311     virtual uint32_t getId() const;
01312     virtual void setId(uint32_t id_var);
01313 };
01314 
01315 inline void doPacking(cCommBuffer *b, DHTgetCAPICall& obj) {obj.parsimPack(b);}
01316 inline void doUnpacking(cCommBuffer *b, DHTgetCAPICall& obj) {obj.parsimUnpack(b);}
01317 
01327 class DHTputCAPIResponse : public ::BaseResponseMessage
01328 {
01329   protected:
01330     bool isSuccess_var;
01331 
01332     // protected and unimplemented operator==(), to prevent accidental usage
01333     bool operator==(const DHTputCAPIResponse&);
01334 
01335   public:
01336     DHTputCAPIResponse(const char *name=NULL, int kind=0);
01337     DHTputCAPIResponse(const DHTputCAPIResponse& other);
01338     virtual ~DHTputCAPIResponse();
01339     DHTputCAPIResponse& operator=(const DHTputCAPIResponse& other);
01340     virtual DHTputCAPIResponse *dup() const {return new DHTputCAPIResponse(*this);}
01341     virtual void parsimPack(cCommBuffer *b);
01342     virtual void parsimUnpack(cCommBuffer *b);
01343 
01344     // field getter/setter methods
01345     virtual bool getIsSuccess() const;
01346     virtual void setIsSuccess(bool isSuccess_var);
01347 };
01348 
01349 inline void doPacking(cCommBuffer *b, DHTputCAPIResponse& obj) {obj.parsimPack(b);}
01350 inline void doUnpacking(cCommBuffer *b, DHTputCAPIResponse& obj) {obj.parsimUnpack(b);}
01351 
01362 class DHTgetCAPIResponse : public ::BaseResponseMessage
01363 {
01364   protected:
01365     ::DhtDumpEntry *result_var; // array ptr
01366     unsigned int result_arraysize;
01367     bool isSuccess_var;
01368 
01369     // protected and unimplemented operator==(), to prevent accidental usage
01370     bool operator==(const DHTgetCAPIResponse&);
01371 
01372   public:
01373     DHTgetCAPIResponse(const char *name=NULL, int kind=0);
01374     DHTgetCAPIResponse(const DHTgetCAPIResponse& other);
01375     virtual ~DHTgetCAPIResponse();
01376     DHTgetCAPIResponse& operator=(const DHTgetCAPIResponse& other);
01377     virtual DHTgetCAPIResponse *dup() const {return new DHTgetCAPIResponse(*this);}
01378     virtual void parsimPack(cCommBuffer *b);
01379     virtual void parsimUnpack(cCommBuffer *b);
01380 
01381     // field getter/setter methods
01382     virtual void setResultArraySize(unsigned int size);
01383     virtual unsigned int getResultArraySize() const;
01384     virtual DhtDumpEntry& getResult(unsigned int k);
01385     virtual const DhtDumpEntry& getResult(unsigned int k) const {return const_cast<DHTgetCAPIResponse*>(this)->getResult(k);}
01386     virtual void setResult(unsigned int k, const DhtDumpEntry& result_var);
01387     virtual bool getIsSuccess() const;
01388     virtual void setIsSuccess(bool isSuccess_var);
01389 };
01390 
01391 inline void doPacking(cCommBuffer *b, DHTgetCAPIResponse& obj) {obj.parsimPack(b);}
01392 inline void doUnpacking(cCommBuffer *b, DHTgetCAPIResponse& obj) {obj.parsimUnpack(b);}
01393 
01402 class DHTdumpCall : public ::BaseCallMessage
01403 {
01404   protected:
01405 
01406     // protected and unimplemented operator==(), to prevent accidental usage
01407     bool operator==(const DHTdumpCall&);
01408 
01409   public:
01410     DHTdumpCall(const char *name=NULL, int kind=0);
01411     DHTdumpCall(const DHTdumpCall& other);
01412     virtual ~DHTdumpCall();
01413     DHTdumpCall& operator=(const DHTdumpCall& other);
01414     virtual DHTdumpCall *dup() const {return new DHTdumpCall(*this);}
01415     virtual void parsimPack(cCommBuffer *b);
01416     virtual void parsimUnpack(cCommBuffer *b);
01417 
01418     // field getter/setter methods
01419 };
01420 
01421 inline void doPacking(cCommBuffer *b, DHTdumpCall& obj) {obj.parsimPack(b);}
01422 inline void doUnpacking(cCommBuffer *b, DHTdumpCall& obj) {obj.parsimUnpack(b);}
01423 
01433 class DHTdumpResponse : public ::BaseResponseMessage
01434 {
01435   protected:
01436     ::DhtDumpEntry *record_var; // array ptr
01437     unsigned int record_arraysize;
01438 
01439     // protected and unimplemented operator==(), to prevent accidental usage
01440     bool operator==(const DHTdumpResponse&);
01441 
01442   public:
01443     DHTdumpResponse(const char *name=NULL, int kind=0);
01444     DHTdumpResponse(const DHTdumpResponse& other);
01445     virtual ~DHTdumpResponse();
01446     DHTdumpResponse& operator=(const DHTdumpResponse& other);
01447     virtual DHTdumpResponse *dup() const {return new DHTdumpResponse(*this);}
01448     virtual void parsimPack(cCommBuffer *b);
01449     virtual void parsimUnpack(cCommBuffer *b);
01450 
01451     // field getter/setter methods
01452     virtual void setRecordArraySize(unsigned int size);
01453     virtual unsigned int getRecordArraySize() const;
01454     virtual DhtDumpEntry& getRecord(unsigned int k);
01455     virtual const DhtDumpEntry& getRecord(unsigned int k) const {return const_cast<DHTdumpResponse*>(this)->getRecord(k);}
01456     virtual void setRecord(unsigned int k, const DhtDumpEntry& record_var);
01457 };
01458 
01459 inline void doPacking(cCommBuffer *b, DHTdumpResponse& obj) {obj.parsimPack(b);}
01460 inline void doUnpacking(cCommBuffer *b, DHTdumpResponse& obj) {obj.parsimUnpack(b);}
01461 
01473 class LookupCall : public ::BaseCallMessage
01474 {
01475   protected:
01476     ::OverlayKey key_var;
01477     int numSiblings_var;
01478     int routingType_var;
01479 
01480     // protected and unimplemented operator==(), to prevent accidental usage
01481     bool operator==(const LookupCall&);
01482 
01483   public:
01484     LookupCall(const char *name=NULL, int kind=0);
01485     LookupCall(const LookupCall& other);
01486     virtual ~LookupCall();
01487     LookupCall& operator=(const LookupCall& other);
01488     virtual LookupCall *dup() const {return new LookupCall(*this);}
01489     virtual void parsimPack(cCommBuffer *b);
01490     virtual void parsimUnpack(cCommBuffer *b);
01491 
01492     // field getter/setter methods
01493     virtual OverlayKey& getKey();
01494     virtual const OverlayKey& getKey() const {return const_cast<LookupCall*>(this)->getKey();}
01495     virtual void setKey(const OverlayKey& key_var);
01496     virtual int getNumSiblings() const;
01497     virtual void setNumSiblings(int numSiblings_var);
01498     virtual int getRoutingType() const;
01499     virtual void setRoutingType(int routingType_var);
01500 };
01501 
01502 inline void doPacking(cCommBuffer *b, LookupCall& obj) {obj.parsimPack(b);}
01503 inline void doUnpacking(cCommBuffer *b, LookupCall& obj) {obj.parsimUnpack(b);}
01504 
01517 class LookupResponse : public ::BaseResponseMessage
01518 {
01519   protected:
01520     ::OverlayKey key_var;
01521     int hopCount_var;
01522     bool isValid_var;
01523     ::NodeHandle *siblings_var; // array ptr
01524     unsigned int siblings_arraysize;
01525 
01526     // protected and unimplemented operator==(), to prevent accidental usage
01527     bool operator==(const LookupResponse&);
01528 
01529   public:
01530     LookupResponse(const char *name=NULL, int kind=0);
01531     LookupResponse(const LookupResponse& other);
01532     virtual ~LookupResponse();
01533     LookupResponse& operator=(const LookupResponse& other);
01534     virtual LookupResponse *dup() const {return new LookupResponse(*this);}
01535     virtual void parsimPack(cCommBuffer *b);
01536     virtual void parsimUnpack(cCommBuffer *b);
01537 
01538     // field getter/setter methods
01539     virtual OverlayKey& getKey();
01540     virtual const OverlayKey& getKey() const {return const_cast<LookupResponse*>(this)->getKey();}
01541     virtual void setKey(const OverlayKey& key_var);
01542     virtual int getHopCount() const;
01543     virtual void setHopCount(int hopCount_var);
01544     virtual bool getIsValid() const;
01545     virtual void setIsValid(bool isValid_var);
01546     virtual void setSiblingsArraySize(unsigned int size);
01547     virtual unsigned int getSiblingsArraySize() const;
01548     virtual NodeHandle& getSiblings(unsigned int k);
01549     virtual const NodeHandle& getSiblings(unsigned int k) const {return const_cast<LookupResponse*>(this)->getSiblings(k);}
01550     virtual void setSiblings(unsigned int k, const NodeHandle& siblings_var);
01551 };
01552 
01553 inline void doPacking(cCommBuffer *b, LookupResponse& obj) {obj.parsimPack(b);}
01554 inline void doUnpacking(cCommBuffer *b, LookupResponse& obj) {obj.parsimUnpack(b);}
01555 
01569 class P2pnsRegisterCall : public ::BaseCallMessage
01570 {
01571   protected:
01572     ::BinaryValue p2pName_var;
01573     uint32_t kind_var;
01574     uint32_t id_var;
01575     ::BinaryValue address_var;
01576     int ttl_var;
01577 
01578     // protected and unimplemented operator==(), to prevent accidental usage
01579     bool operator==(const P2pnsRegisterCall&);
01580 
01581   public:
01582     P2pnsRegisterCall(const char *name=NULL, int kind=0);
01583     P2pnsRegisterCall(const P2pnsRegisterCall& other);
01584     virtual ~P2pnsRegisterCall();
01585     P2pnsRegisterCall& operator=(const P2pnsRegisterCall& other);
01586     virtual P2pnsRegisterCall *dup() const {return new P2pnsRegisterCall(*this);}
01587     virtual void parsimPack(cCommBuffer *b);
01588     virtual void parsimUnpack(cCommBuffer *b);
01589 
01590     // field getter/setter methods
01591     virtual BinaryValue& getP2pName();
01592     virtual const BinaryValue& getP2pName() const {return const_cast<P2pnsRegisterCall*>(this)->getP2pName();}
01593     virtual void setP2pName(const BinaryValue& p2pName_var);
01594     virtual uint32_t getKind() const;
01595     virtual void setKind(uint32_t kind_var);
01596     virtual uint32_t getId() const;
01597     virtual void setId(uint32_t id_var);
01598     virtual BinaryValue& getAddress();
01599     virtual const BinaryValue& getAddress() const {return const_cast<P2pnsRegisterCall*>(this)->getAddress();}
01600     virtual void setAddress(const BinaryValue& address_var);
01601     virtual int getTtl() const;
01602     virtual void setTtl(int ttl_var);
01603 };
01604 
01605 inline void doPacking(cCommBuffer *b, P2pnsRegisterCall& obj) {obj.parsimPack(b);}
01606 inline void doUnpacking(cCommBuffer *b, P2pnsRegisterCall& obj) {obj.parsimUnpack(b);}
01607 
01619 class P2pnsRegisterResponse : public ::BaseResponseMessage
01620 {
01621   protected:
01622     ::BinaryValue p2pName_var;
01623     ::BinaryValue address_var;
01624     bool isSuccess_var;
01625 
01626     // protected and unimplemented operator==(), to prevent accidental usage
01627     bool operator==(const P2pnsRegisterResponse&);
01628 
01629   public:
01630     P2pnsRegisterResponse(const char *name=NULL, int kind=0);
01631     P2pnsRegisterResponse(const P2pnsRegisterResponse& other);
01632     virtual ~P2pnsRegisterResponse();
01633     P2pnsRegisterResponse& operator=(const P2pnsRegisterResponse& other);
01634     virtual P2pnsRegisterResponse *dup() const {return new P2pnsRegisterResponse(*this);}
01635     virtual void parsimPack(cCommBuffer *b);
01636     virtual void parsimUnpack(cCommBuffer *b);
01637 
01638     // field getter/setter methods
01639     virtual BinaryValue& getP2pName();
01640     virtual const BinaryValue& getP2pName() const {return const_cast<P2pnsRegisterResponse*>(this)->getP2pName();}
01641     virtual void setP2pName(const BinaryValue& p2pName_var);
01642     virtual BinaryValue& getAddress();
01643     virtual const BinaryValue& getAddress() const {return const_cast<P2pnsRegisterResponse*>(this)->getAddress();}
01644     virtual void setAddress(const BinaryValue& address_var);
01645     virtual bool getIsSuccess() const;
01646     virtual void setIsSuccess(bool isSuccess_var);
01647 };
01648 
01649 inline void doPacking(cCommBuffer *b, P2pnsRegisterResponse& obj) {obj.parsimPack(b);}
01650 inline void doUnpacking(cCommBuffer *b, P2pnsRegisterResponse& obj) {obj.parsimUnpack(b);}
01651 
01663 class P2pnsResolveCall : public ::BaseCallMessage
01664 {
01665   protected:
01666     ::BinaryValue p2pName_var;
01667     uint32_t kind_var;
01668     uint32_t id_var;
01669 
01670     // protected and unimplemented operator==(), to prevent accidental usage
01671     bool operator==(const P2pnsResolveCall&);
01672 
01673   public:
01674     P2pnsResolveCall(const char *name=NULL, int kind=0);
01675     P2pnsResolveCall(const P2pnsResolveCall& other);
01676     virtual ~P2pnsResolveCall();
01677     P2pnsResolveCall& operator=(const P2pnsResolveCall& other);
01678     virtual P2pnsResolveCall *dup() const {return new P2pnsResolveCall(*this);}
01679     virtual void parsimPack(cCommBuffer *b);
01680     virtual void parsimUnpack(cCommBuffer *b);
01681 
01682     // field getter/setter methods
01683     virtual BinaryValue& getP2pName();
01684     virtual const BinaryValue& getP2pName() const {return const_cast<P2pnsResolveCall*>(this)->getP2pName();}
01685     virtual void setP2pName(const BinaryValue& p2pName_var);
01686     virtual uint32_t getKind() const;
01687     virtual void setKind(uint32_t kind_var);
01688     virtual uint32_t getId() const;
01689     virtual void setId(uint32_t id_var);
01690 };
01691 
01692 inline void doPacking(cCommBuffer *b, P2pnsResolveCall& obj) {obj.parsimPack(b);}
01693 inline void doUnpacking(cCommBuffer *b, P2pnsResolveCall& obj) {obj.parsimUnpack(b);}
01694 
01708 class P2pnsResolveResponse : public ::BaseResponseMessage
01709 {
01710   protected:
01711     ::BinaryValue p2pName_var;
01712     ::BinaryValue *address_var; // array ptr
01713     unsigned int address_arraysize;
01714     uint32_t *kind_var; // array ptr
01715     unsigned int kind_arraysize;
01716     uint32_t *id_var; // array ptr
01717     unsigned int id_arraysize;
01718     bool isSuccess_var;
01719 
01720     // protected and unimplemented operator==(), to prevent accidental usage
01721     bool operator==(const P2pnsResolveResponse&);
01722 
01723   public:
01724     P2pnsResolveResponse(const char *name=NULL, int kind=0);
01725     P2pnsResolveResponse(const P2pnsResolveResponse& other);
01726     virtual ~P2pnsResolveResponse();
01727     P2pnsResolveResponse& operator=(const P2pnsResolveResponse& other);
01728     virtual P2pnsResolveResponse *dup() const {return new P2pnsResolveResponse(*this);}
01729     virtual void parsimPack(cCommBuffer *b);
01730     virtual void parsimUnpack(cCommBuffer *b);
01731 
01732     // field getter/setter methods
01733     virtual BinaryValue& getP2pName();
01734     virtual const BinaryValue& getP2pName() const {return const_cast<P2pnsResolveResponse*>(this)->getP2pName();}
01735     virtual void setP2pName(const BinaryValue& p2pName_var);
01736     virtual void setAddressArraySize(unsigned int size);
01737     virtual unsigned int getAddressArraySize() const;
01738     virtual BinaryValue& getAddress(unsigned int k);
01739     virtual const BinaryValue& getAddress(unsigned int k) const {return const_cast<P2pnsResolveResponse*>(this)->getAddress(k);}
01740     virtual void setAddress(unsigned int k, const BinaryValue& address_var);
01741     virtual void setKindArraySize(unsigned int size);
01742     virtual unsigned int getKindArraySize() const;
01743     virtual uint32_t getKind(unsigned int k) const;
01744     virtual void setKind(unsigned int k, uint32_t kind_var);
01745     virtual void setIdArraySize(unsigned int size);
01746     virtual unsigned int getIdArraySize() const;
01747     virtual uint32_t getId(unsigned int k) const;
01748     virtual void setId(unsigned int k, uint32_t id_var);
01749     virtual bool getIsSuccess() const;
01750     virtual void setIsSuccess(bool isSuccess_var);
01751 };
01752 
01753 inline void doPacking(cCommBuffer *b, P2pnsResolveResponse& obj) {obj.parsimPack(b);}
01754 inline void doUnpacking(cCommBuffer *b, P2pnsResolveResponse& obj) {obj.parsimUnpack(b);}
01755 
01773 class OverlayCtrlInfo : public ::cObject
01774 {
01775   protected:
01776     ::TransportAddress lastHop_var;
01777     ::NodeHandle srcNode_var;
01778     ::NodeHandle srcRoute_var;
01779     int hopCount_var;
01780     ::TransportAddress *visitedHops_var; // array ptr
01781     unsigned int visitedHops_arraysize;
01782     int srcComp_var;
01783     int destComp_var;
01784     int transportType_var;
01785     int routingType_var;
01786 
01787     // protected and unimplemented operator==(), to prevent accidental usage
01788     bool operator==(const OverlayCtrlInfo&);
01789 
01790   public:
01791     OverlayCtrlInfo();
01792     OverlayCtrlInfo(const OverlayCtrlInfo& other);
01793     virtual ~OverlayCtrlInfo();
01794     OverlayCtrlInfo& operator=(const OverlayCtrlInfo& other);
01795     virtual OverlayCtrlInfo *dup() const {return new OverlayCtrlInfo(*this);}
01796     virtual void parsimPack(cCommBuffer *b);
01797     virtual void parsimUnpack(cCommBuffer *b);
01798 
01799     // field getter/setter methods
01800     virtual TransportAddress& getLastHop();
01801     virtual const TransportAddress& getLastHop() const {return const_cast<OverlayCtrlInfo*>(this)->getLastHop();}
01802     virtual void setLastHop(const TransportAddress& lastHop_var);
01803     virtual NodeHandle& getSrcNode();
01804     virtual const NodeHandle& getSrcNode() const {return const_cast<OverlayCtrlInfo*>(this)->getSrcNode();}
01805     virtual void setSrcNode(const NodeHandle& srcNode_var);
01806     virtual NodeHandle& getSrcRoute();
01807     virtual const NodeHandle& getSrcRoute() const {return const_cast<OverlayCtrlInfo*>(this)->getSrcRoute();}
01808     virtual void setSrcRoute(const NodeHandle& srcRoute_var);
01809     virtual int getHopCount() const;
01810     virtual void setHopCount(int hopCount_var);
01811     virtual void setVisitedHopsArraySize(unsigned int size);
01812     virtual unsigned int getVisitedHopsArraySize() const;
01813     virtual TransportAddress& getVisitedHops(unsigned int k);
01814     virtual const TransportAddress& getVisitedHops(unsigned int k) const {return const_cast<OverlayCtrlInfo*>(this)->getVisitedHops(k);}
01815     virtual void setVisitedHops(unsigned int k, const TransportAddress& visitedHops_var);
01816     virtual int getSrcComp() const;
01817     virtual void setSrcComp(int srcComp_var);
01818     virtual int getDestComp() const;
01819     virtual void setDestComp(int destComp_var);
01820     virtual int getTransportType() const;
01821     virtual void setTransportType(int transportType_var);
01822     virtual int getRoutingType() const;
01823     virtual void setRoutingType(int routingType_var);
01824 };
01825 
01826 inline void doPacking(cCommBuffer *b, OverlayCtrlInfo& obj) {obj.parsimPack(b);}
01827 inline void doUnpacking(cCommBuffer *b, OverlayCtrlInfo& obj) {obj.parsimUnpack(b);}
01828 
01838 class ALMMessage : public ::cPacket
01839 {
01840   protected:
01841     ::OverlayKey groupId_var;
01842 
01843     // protected and unimplemented operator==(), to prevent accidental usage
01844     bool operator==(const ALMMessage&);
01845 
01846   public:
01847     ALMMessage(const char *name=NULL, int kind=0);
01848     ALMMessage(const ALMMessage& other);
01849     virtual ~ALMMessage();
01850     ALMMessage& operator=(const ALMMessage& other);
01851     virtual ALMMessage *dup() const {return new ALMMessage(*this);}
01852     virtual void parsimPack(cCommBuffer *b);
01853     virtual void parsimUnpack(cCommBuffer *b);
01854 
01855     // field getter/setter methods
01856     virtual OverlayKey& getGroupId();
01857     virtual const OverlayKey& getGroupId() const {return const_cast<ALMMessage*>(this)->getGroupId();}
01858     virtual void setGroupId(const OverlayKey& groupId_var);
01859 };
01860 
01861 inline void doPacking(cCommBuffer *b, ALMMessage& obj) {obj.parsimPack(b);}
01862 inline void doUnpacking(cCommBuffer *b, ALMMessage& obj) {obj.parsimUnpack(b);}
01863 
01872 class ALMCreateMessage : public ::ALMMessage
01873 {
01874   protected:
01875 
01876     // protected and unimplemented operator==(), to prevent accidental usage
01877     bool operator==(const ALMCreateMessage&);
01878 
01879   public:
01880     ALMCreateMessage(const char *name=NULL, int kind=0);
01881     ALMCreateMessage(const ALMCreateMessage& other);
01882     virtual ~ALMCreateMessage();
01883     ALMCreateMessage& operator=(const ALMCreateMessage& other);
01884     virtual ALMCreateMessage *dup() const {return new ALMCreateMessage(*this);}
01885     virtual void parsimPack(cCommBuffer *b);
01886     virtual void parsimUnpack(cCommBuffer *b);
01887 
01888     // field getter/setter methods
01889 };
01890 
01891 inline void doPacking(cCommBuffer *b, ALMCreateMessage& obj) {obj.parsimPack(b);}
01892 inline void doUnpacking(cCommBuffer *b, ALMCreateMessage& obj) {obj.parsimUnpack(b);}
01893 
01902 class ALMDeleteMessage : public ::ALMMessage
01903 {
01904   protected:
01905 
01906     // protected and unimplemented operator==(), to prevent accidental usage
01907     bool operator==(const ALMDeleteMessage&);
01908 
01909   public:
01910     ALMDeleteMessage(const char *name=NULL, int kind=0);
01911     ALMDeleteMessage(const ALMDeleteMessage& other);
01912     virtual ~ALMDeleteMessage();
01913     ALMDeleteMessage& operator=(const ALMDeleteMessage& other);
01914     virtual ALMDeleteMessage *dup() const {return new ALMDeleteMessage(*this);}
01915     virtual void parsimPack(cCommBuffer *b);
01916     virtual void parsimUnpack(cCommBuffer *b);
01917 
01918     // field getter/setter methods
01919 };
01920 
01921 inline void doPacking(cCommBuffer *b, ALMDeleteMessage& obj) {obj.parsimPack(b);}
01922 inline void doUnpacking(cCommBuffer *b, ALMDeleteMessage& obj) {obj.parsimUnpack(b);}
01923 
01932 class ALMSubscribeMessage : public ::ALMMessage
01933 {
01934   protected:
01935 
01936     // protected and unimplemented operator==(), to prevent accidental usage
01937     bool operator==(const ALMSubscribeMessage&);
01938 
01939   public:
01940     ALMSubscribeMessage(const char *name=NULL, int kind=0);
01941     ALMSubscribeMessage(const ALMSubscribeMessage& other);
01942     virtual ~ALMSubscribeMessage();
01943     ALMSubscribeMessage& operator=(const ALMSubscribeMessage& other);
01944     virtual ALMSubscribeMessage *dup() const {return new ALMSubscribeMessage(*this);}
01945     virtual void parsimPack(cCommBuffer *b);
01946     virtual void parsimUnpack(cCommBuffer *b);
01947 
01948     // field getter/setter methods
01949 };
01950 
01951 inline void doPacking(cCommBuffer *b, ALMSubscribeMessage& obj) {obj.parsimPack(b);}
01952 inline void doUnpacking(cCommBuffer *b, ALMSubscribeMessage& obj) {obj.parsimUnpack(b);}
01953 
01962 class ALMLeaveMessage : public ::ALMMessage
01963 {
01964   protected:
01965 
01966     // protected and unimplemented operator==(), to prevent accidental usage
01967     bool operator==(const ALMLeaveMessage&);
01968 
01969   public:
01970     ALMLeaveMessage(const char *name=NULL, int kind=0);
01971     ALMLeaveMessage(const ALMLeaveMessage& other);
01972     virtual ~ALMLeaveMessage();
01973     ALMLeaveMessage& operator=(const ALMLeaveMessage& other);
01974     virtual ALMLeaveMessage *dup() const {return new ALMLeaveMessage(*this);}
01975     virtual void parsimPack(cCommBuffer *b);
01976     virtual void parsimUnpack(cCommBuffer *b);
01977 
01978     // field getter/setter methods
01979 };
01980 
01981 inline void doPacking(cCommBuffer *b, ALMLeaveMessage& obj) {obj.parsimPack(b);}
01982 inline void doUnpacking(cCommBuffer *b, ALMLeaveMessage& obj) {obj.parsimUnpack(b);}
01983 
01992 class ALMMulticastMessage : public ::ALMMessage
01993 {
01994   protected:
01995 
01996     // protected and unimplemented operator==(), to prevent accidental usage
01997     bool operator==(const ALMMulticastMessage&);
01998 
01999   public:
02000     ALMMulticastMessage(const char *name=NULL, int kind=0);
02001     ALMMulticastMessage(const ALMMulticastMessage& other);
02002     virtual ~ALMMulticastMessage();
02003     ALMMulticastMessage& operator=(const ALMMulticastMessage& other);
02004     virtual ALMMulticastMessage *dup() const {return new ALMMulticastMessage(*this);}
02005     virtual void parsimPack(cCommBuffer *b);
02006     virtual void parsimUnpack(cCommBuffer *b);
02007 
02008     // field getter/setter methods
02009 };
02010 
02011 inline void doPacking(cCommBuffer *b, ALMMulticastMessage& obj) {obj.parsimPack(b);}
02012 inline void doUnpacking(cCommBuffer *b, ALMMulticastMessage& obj) {obj.parsimUnpack(b);}
02013 
02022 class ALMAnycastMessage : public ::ALMMessage
02023 {
02024   protected:
02025 
02026     // protected and unimplemented operator==(), to prevent accidental usage
02027     bool operator==(const ALMAnycastMessage&);
02028 
02029   public:
02030     ALMAnycastMessage(const char *name=NULL, int kind=0);
02031     ALMAnycastMessage(const ALMAnycastMessage& other);
02032     virtual ~ALMAnycastMessage();
02033     ALMAnycastMessage& operator=(const ALMAnycastMessage& other);
02034     virtual ALMAnycastMessage *dup() const {return new ALMAnycastMessage(*this);}
02035     virtual void parsimPack(cCommBuffer *b);
02036     virtual void parsimUnpack(cCommBuffer *b);
02037 
02038     // field getter/setter methods
02039 };
02040 
02041 inline void doPacking(cCommBuffer *b, ALMAnycastMessage& obj) {obj.parsimPack(b);}
02042 inline void doUnpacking(cCommBuffer *b, ALMAnycastMessage& obj) {obj.parsimUnpack(b);}
02043 
02053 class GameAPIMessage : public ::BaseOverlayMessage
02054 {
02055   protected:
02056     int command_var;
02057 
02058     // protected and unimplemented operator==(), to prevent accidental usage
02059     bool operator==(const GameAPIMessage&);
02060 
02061   public:
02062     GameAPIMessage(const char *name=NULL, int kind=0);
02063     GameAPIMessage(const GameAPIMessage& other);
02064     virtual ~GameAPIMessage();
02065     GameAPIMessage& operator=(const GameAPIMessage& other);
02066     virtual GameAPIMessage *dup() const {return new GameAPIMessage(*this);}
02067     virtual void parsimPack(cCommBuffer *b);
02068     virtual void parsimUnpack(cCommBuffer *b);
02069 
02070     // field getter/setter methods
02071     virtual int getCommand() const;
02072     virtual void setCommand(int command_var);
02073 };
02074 
02075 inline void doPacking(cCommBuffer *b, GameAPIMessage& obj) {obj.parsimPack(b);}
02076 inline void doUnpacking(cCommBuffer *b, GameAPIMessage& obj) {obj.parsimUnpack(b);}
02077 
02089 class GameAPIListMessage : public ::GameAPIMessage
02090 {
02091   protected:
02092     ::NodeHandle *removeNeighbor_var; // array ptr
02093     unsigned int removeNeighbor_arraysize;
02094     ::NodeHandle *addNeighbor_var; // array ptr
02095     unsigned int addNeighbor_arraysize;
02096     ::Vector2D *neighborPosition_var; // array ptr
02097     unsigned int neighborPosition_arraysize;
02098 
02099     // protected and unimplemented operator==(), to prevent accidental usage
02100     bool operator==(const GameAPIListMessage&);
02101 
02102   public:
02103     GameAPIListMessage(const char *name=NULL, int kind=0);
02104     GameAPIListMessage(const GameAPIListMessage& other);
02105     virtual ~GameAPIListMessage();
02106     GameAPIListMessage& operator=(const GameAPIListMessage& other);
02107     virtual GameAPIListMessage *dup() const {return new GameAPIListMessage(*this);}
02108     virtual void parsimPack(cCommBuffer *b);
02109     virtual void parsimUnpack(cCommBuffer *b);
02110 
02111     // field getter/setter methods
02112     virtual void setRemoveNeighborArraySize(unsigned int size);
02113     virtual unsigned int getRemoveNeighborArraySize() const;
02114     virtual NodeHandle& getRemoveNeighbor(unsigned int k);
02115     virtual const NodeHandle& getRemoveNeighbor(unsigned int k) const {return const_cast<GameAPIListMessage*>(this)->getRemoveNeighbor(k);}
02116     virtual void setRemoveNeighbor(unsigned int k, const NodeHandle& removeNeighbor_var);
02117     virtual void setAddNeighborArraySize(unsigned int size);
02118     virtual unsigned int getAddNeighborArraySize() const;
02119     virtual NodeHandle& getAddNeighbor(unsigned int k);
02120     virtual const NodeHandle& getAddNeighbor(unsigned int k) const {return const_cast<GameAPIListMessage*>(this)->getAddNeighbor(k);}
02121     virtual void setAddNeighbor(unsigned int k, const NodeHandle& addNeighbor_var);
02122     virtual void setNeighborPositionArraySize(unsigned int size);
02123     virtual unsigned int getNeighborPositionArraySize() const;
02124     virtual Vector2D& getNeighborPosition(unsigned int k);
02125     virtual const Vector2D& getNeighborPosition(unsigned int k) const {return const_cast<GameAPIListMessage*>(this)->getNeighborPosition(k);}
02126     virtual void setNeighborPosition(unsigned int k, const Vector2D& neighborPosition_var);
02127 };
02128 
02129 inline void doPacking(cCommBuffer *b, GameAPIListMessage& obj) {obj.parsimPack(b);}
02130 inline void doUnpacking(cCommBuffer *b, GameAPIListMessage& obj) {obj.parsimUnpack(b);}
02131 
02141 class GameAPIPositionMessage : public ::GameAPIMessage
02142 {
02143   protected:
02144     ::Vector2D position_var;
02145 
02146     // protected and unimplemented operator==(), to prevent accidental usage
02147     bool operator==(const GameAPIPositionMessage&);
02148 
02149   public:
02150     GameAPIPositionMessage(const char *name=NULL, int kind=0);
02151     GameAPIPositionMessage(const GameAPIPositionMessage& other);
02152     virtual ~GameAPIPositionMessage();
02153     GameAPIPositionMessage& operator=(const GameAPIPositionMessage& other);
02154     virtual GameAPIPositionMessage *dup() const {return new GameAPIPositionMessage(*this);}
02155     virtual void parsimPack(cCommBuffer *b);
02156     virtual void parsimUnpack(cCommBuffer *b);
02157 
02158     // field getter/setter methods
02159     virtual Vector2D& getPosition();
02160     virtual const Vector2D& getPosition() const {return const_cast<GameAPIPositionMessage*>(this)->getPosition();}
02161     virtual void setPosition(const Vector2D& position_var);
02162 };
02163 
02164 inline void doPacking(cCommBuffer *b, GameAPIPositionMessage& obj) {obj.parsimPack(b);}
02165 inline void doUnpacking(cCommBuffer *b, GameAPIPositionMessage& obj) {obj.parsimUnpack(b);}
02166 
02176 class GameAPIResizeAOIMessage : public ::GameAPIMessage
02177 {
02178   protected:
02179     double AOIsize_var;
02180 
02181     // protected and unimplemented operator==(), to prevent accidental usage
02182     bool operator==(const GameAPIResizeAOIMessage&);
02183 
02184   public:
02185     GameAPIResizeAOIMessage(const char *name=NULL, int kind=0);
02186     GameAPIResizeAOIMessage(const GameAPIResizeAOIMessage& other);
02187     virtual ~GameAPIResizeAOIMessage();
02188     GameAPIResizeAOIMessage& operator=(const GameAPIResizeAOIMessage& other);
02189     virtual GameAPIResizeAOIMessage *dup() const {return new GameAPIResizeAOIMessage(*this);}
02190     virtual void parsimPack(cCommBuffer *b);
02191     virtual void parsimUnpack(cCommBuffer *b);
02192 
02193     // field getter/setter methods
02194     virtual double getAOIsize() const;
02195     virtual void setAOIsize(double AOIsize_var);
02196 };
02197 
02198 inline void doPacking(cCommBuffer *b, GameAPIResizeAOIMessage& obj) {obj.parsimPack(b);}
02199 inline void doUnpacking(cCommBuffer *b, GameAPIResizeAOIMessage& obj) {obj.parsimUnpack(b);}
02200 
02211 class GameAPIChatMessage : public ::GameAPIMessage
02212 {
02213   protected:
02214     ::NodeHandle src_var;
02215     opp_string msg_var;
02216 
02217     // protected and unimplemented operator==(), to prevent accidental usage
02218     bool operator==(const GameAPIChatMessage&);
02219 
02220   public:
02221     GameAPIChatMessage(const char *name=NULL, int kind=0);
02222     GameAPIChatMessage(const GameAPIChatMessage& other);
02223     virtual ~GameAPIChatMessage();
02224     GameAPIChatMessage& operator=(const GameAPIChatMessage& other);
02225     virtual GameAPIChatMessage *dup() const {return new GameAPIChatMessage(*this);}
02226     virtual void parsimPack(cCommBuffer *b);
02227     virtual void parsimUnpack(cCommBuffer *b);
02228 
02229     // field getter/setter methods
02230     virtual NodeHandle& getSrc();
02231     virtual const NodeHandle& getSrc() const {return const_cast<GameAPIChatMessage*>(this)->getSrc();}
02232     virtual void setSrc(const NodeHandle& src_var);
02233     virtual const char * getMsg() const;
02234     virtual void setMsg(const char * msg_var);
02235 };
02236 
02237 inline void doPacking(cCommBuffer *b, GameAPIChatMessage& obj) {obj.parsimPack(b);}
02238 inline void doUnpacking(cCommBuffer *b, GameAPIChatMessage& obj) {obj.parsimUnpack(b);}
02239 
02253 class GameAPISnowMessage : public ::GameAPIMessage
02254 {
02255   protected:
02256     ::NodeHandle src_var;
02257     ::Vector2D start_var;
02258     ::Vector2D end_var;
02259     int timeSec_var;
02260     int timeUsec_var;
02261 
02262     // protected and unimplemented operator==(), to prevent accidental usage
02263     bool operator==(const GameAPISnowMessage&);
02264 
02265   public:
02266     GameAPISnowMessage(const char *name=NULL, int kind=0);
02267     GameAPISnowMessage(const GameAPISnowMessage& other);
02268     virtual ~GameAPISnowMessage();
02269     GameAPISnowMessage& operator=(const GameAPISnowMessage& other);
02270     virtual GameAPISnowMessage *dup() const {return new GameAPISnowMessage(*this);}
02271     virtual void parsimPack(cCommBuffer *b);
02272     virtual void parsimUnpack(cCommBuffer *b);
02273 
02274     // field getter/setter methods
02275     virtual NodeHandle& getSrc();
02276     virtual const NodeHandle& getSrc() const {return const_cast<GameAPISnowMessage*>(this)->getSrc();}
02277     virtual void setSrc(const NodeHandle& src_var);
02278     virtual Vector2D& getStart();
02279     virtual const Vector2D& getStart() const {return const_cast<GameAPISnowMessage*>(this)->getStart();}
02280     virtual void setStart(const Vector2D& start_var);
02281     virtual Vector2D& getEnd();
02282     virtual const Vector2D& getEnd() const {return const_cast<GameAPISnowMessage*>(this)->getEnd();}
02283     virtual void setEnd(const Vector2D& end_var);
02284     virtual int getTimeSec() const;
02285     virtual void setTimeSec(int timeSec_var);
02286     virtual int getTimeUsec() const;
02287     virtual void setTimeUsec(int timeUsec_var);
02288 };
02289 
02290 inline void doPacking(cCommBuffer *b, GameAPISnowMessage& obj) {obj.parsimPack(b);}
02291 inline void doUnpacking(cCommBuffer *b, GameAPISnowMessage& obj) {obj.parsimUnpack(b);}
02292 
02305 class GameAPIFrozenMessage : public ::GameAPIMessage
02306 {
02307   protected:
02308     ::NodeHandle src_var;
02309     int thrower_var;
02310     int timeSec_var;
02311     int timeUsec_var;
02312 
02313     // protected and unimplemented operator==(), to prevent accidental usage
02314     bool operator==(const GameAPIFrozenMessage&);
02315 
02316   public:
02317     GameAPIFrozenMessage(const char *name=NULL, int kind=0);
02318     GameAPIFrozenMessage(const GameAPIFrozenMessage& other);
02319     virtual ~GameAPIFrozenMessage();
02320     GameAPIFrozenMessage& operator=(const GameAPIFrozenMessage& other);
02321     virtual GameAPIFrozenMessage *dup() const {return new GameAPIFrozenMessage(*this);}
02322     virtual void parsimPack(cCommBuffer *b);
02323     virtual void parsimUnpack(cCommBuffer *b);
02324 
02325     // field getter/setter methods
02326     virtual NodeHandle& getSrc();
02327     virtual const NodeHandle& getSrc() const {return const_cast<GameAPIFrozenMessage*>(this)->getSrc();}
02328     virtual void setSrc(const NodeHandle& src_var);
02329     virtual int getThrower() const;
02330     virtual void setThrower(int thrower_var);
02331     virtual int getTimeSec() const;
02332     virtual void setTimeSec(int timeSec_var);
02333     virtual int getTimeUsec() const;
02334     virtual void setTimeUsec(int timeUsec_var);
02335 };
02336 
02337 inline void doPacking(cCommBuffer *b, GameAPIFrozenMessage& obj) {obj.parsimPack(b);}
02338 inline void doUnpacking(cCommBuffer *b, GameAPIFrozenMessage& obj) {obj.parsimUnpack(b);}
02339 
02340 
02341 #endif // _COMMONMESSAGES_M_H_