PubSubMessage_m.h

Go to the documentation of this file.
00001 //
00002 // Generated file, do not edit! Created by opp_msgc 4.0 from overlay/pubsubmmog/PubSubMessage.msg.
00003 //
00004 
00005 #ifndef _PUBSUBMESSAGE_M_H_
00006 #define _PUBSUBMESSAGE_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 <CommonMessages_m.h>
00019 #include <Vector2D.h>
00020 
00021 static const int PUBSUB_FLAG_L = 8;
00022 static const int PUBSUB_VECTOR_L = 128;
00023 static const int PUBSUB_RESS_L = 32;
00024 static const int PUBSUB_SUBSPACE_L = 32;
00025 static const int PUBSUB_CHILDPOS_L = 16;
00026 static const int PUBSUB_TIMESTAMP_L = 32;
00027 
00028 #define PUBSUB_JOINCALL_L(msg) (BASECALL_L(msg) + PUBSUB_VECTOR_L + PUBSUB_RESS_L)
00029 #define PUBSUB_JOINRESPONSE_L(msg) (BASECALL_L(msg) + NODEHANDLE_L)
00030 #define PUBSUB_RESPONSIBLENODECALL_L(msg) (BASECALL_L(msg) + PUBSUB_VECTOR_L)
00031 #define PUBSUB_RESPONSIBLENODERESPONSE_L(msg) (BASECALL_L(msg) + NODEHANDLE_L)
00032 #define PUBSUB_TAKEOVERSUBSPACECALL_L(msg) (BASECALL_L(msg) + PUBSUB_VECTOR_L)
00033 #define PUBSUB_TAKEOVERSUBSPACERESPONSE_L(msg) (BASECALL_L(msg))
00034 #define PUBSUB_SUBSCRIPTIONCALL_L(msg) (BASECALL_L(msg) + PUBSUB_SUBSPACE_L)
00035 #define PUBSUB_SUBSCRIPTIONRESPONSE_L(msg) (BASECALL_L(msg) + PUBSUB_FLAG_L)
00036 #define PUBSUB_UNSUBSCRIPTION_L(msg) (NODEHANDLE_L + PUBSUB_SUBSPACE_L)
00037 #define PUBSUB_HELPCALL_L(msg) (BASECALL_L(msg) + PUBSUB_SUBSPACE_L + PUBSUB_FLAG_L)
00038 #define PUBSUB_HELPRESPONSE_L(msg) (BASECALL_L(msg) + NODEHANDLE_L)
00039 #define PUBSUB_INTERMEDIATECALL_L(msg) (BASECALL_L(msg) + PUBSUB_SUBSPACE_L)
00040 #define PUBSUB_INTERMEDIATERESPONSE_L(msg) (BASECALL_L(msg))
00041 #define PUBSUB_BACKUPCALL_L(msg) (BASECALL_L(msg) + msg->getIntermediatesArraySize()*NODEHANDLE_L + msg->getChildrenArraySize()*(NODEHANDLE_L+PUBSUB_CHILDPOS_L))
00042 #define PUBSUB_BACKUPRESPONSE_L(msg) (BASECALL_L(msg))
00043 #define PUBSUB_PINGCALL_L(msg) (BASECALL_L(msg) + PUBSUB_SUBSPACE_L + PUBSUB_FLAG_L)
00044 #define PUBSUB_PINGRESPONSE_L(msg) (BASECALL_L(msg))
00045 #define PUBSUB_REPLACEMENT_L(msg) (PUBSUB_SUBSPACE_L + NODEHANDLE_L)
00046 #define PUBSUB_FAILEDNODE_L(msg) (IPADDR_L + UDPPORT_L)
00047 #define PUBSUB_NODELEFT_L(msg) (PUBSUB_SUBSPACE_L + NODEHANDLE_L)
00048 #define PUBSUB_ADOPTCHILDCALL_L(msg) (BASECALL_L(msg) + PUBSUB_SUBSPACE_L + NODEHANDLE_L)
00049 #define PUBSUB_ADOPTCHILDRESPONSE_L(msg) (BASECALL_L(msg))
00050 #define PUBSUB_RELEASEINTERMEDIATE_L(msg) (PUBSUB_SUBSPACE_L)
00051 #define PUBSUB_HELPRELEASE_L(msg) (PUBSUB_SUBSPACE_L + NODEHANDLE_L)
00052 #define PUBSUB_BACKUPSUBSCRIPTION_L(msg) (PUBSUB_SUBSPACE_L + NODEHANDLE_L*3)
00053 #define PUBSUB_BACKUPINTERMEDIATE_L(msg) (PUBSUB_SUBSPACE_L + NODEHANDLE_L + PUBSUB_CHILDPOS_L)
00054 #define PUBSUB_BACKUPUNSUBSCRIBE_L(msg) (PUBSUB_SUBSPACE_L + NODEHANDLE_L*2)
00055 #define PUBSUB_MOVE_L(msg) (PUBSUB_SUBSPACE_L + NODEHANDLE_L + PUBSUB_VECTOR_L + PUBSUB_TIMESTAMP_L)
00056 #define PUBSUB_MOVELIST_L(msg) (PUBSUB_SUBSPACE_L + PUBSUB_TIMESTAMP_L + msg->getPlayerArraySize()*(NODEHANDLE_L+PUBSUB_VECTOR_L))
00057 
00058 // end cplusplus
00059 
00060 
00061 
00076 enum PubSubTimerType {
00077     PUBSUB_HEARTBEAT = 0,
00078     PUBSUB_CHILDPING = 1,
00079     PUBSUB_PARENT_TIMEOUT = 2,
00080     PUBSUB_TAKEOVER_GRACE_TIME = 3,
00081     PUBSUB_EVENTDELIVERY = 4
00082 };
00083 
00095 enum PubSubHelpType {
00096     PUBSUB_BACKUP = 0,
00097     PUBSUB_INTERMEDIATE = 1
00098 };
00099 
00112 enum PubSubPingType {
00113     PUBSUB_PING_BACKUP = 0,
00114     PUBSUB_PING_INTERMEDIATE = 1,
00115     PUBSUB_PING_CHILD = 2
00116 };
00117 
00128 class PubSubTimer : public cMessage
00129 {
00130   protected:
00131     int type_var;
00132     int subspaceId_var;
00133 
00134     // protected and unimplemented operator==(), to prevent accidental usage
00135     bool operator==(const PubSubTimer&);
00136 
00137   public:
00138     PubSubTimer(const char *name=NULL, int kind=0);
00139     PubSubTimer(const PubSubTimer& other);
00140     virtual ~PubSubTimer();
00141     PubSubTimer& operator=(const PubSubTimer& other);
00142     virtual PubSubTimer *dup() const {return new PubSubTimer(*this);}
00143     virtual void parsimPack(cCommBuffer *b);
00144     virtual void parsimUnpack(cCommBuffer *b);
00145 
00146     // field getter/setter methods
00147     virtual int getType() const;
00148     virtual void setType(int type_var);
00149     virtual int getSubspaceId() const;
00150     virtual void setSubspaceId(int subspaceId_var);
00151 };
00152 
00153 inline void doPacking(cCommBuffer *b, PubSubTimer& obj) {obj.parsimPack(b);}
00154 inline void doUnpacking(cCommBuffer *b, PubSubTimer& obj) {obj.parsimUnpack(b);}
00155 
00166 class PubSubJoinCall : public BaseCallMessage
00167 {
00168   protected:
00169     Vector2D position_var;
00170     int ressources_var;
00171 
00172     // protected and unimplemented operator==(), to prevent accidental usage
00173     bool operator==(const PubSubJoinCall&);
00174 
00175   public:
00176     PubSubJoinCall(const char *name=NULL, int kind=0);
00177     PubSubJoinCall(const PubSubJoinCall& other);
00178     virtual ~PubSubJoinCall();
00179     PubSubJoinCall& operator=(const PubSubJoinCall& other);
00180     virtual PubSubJoinCall *dup() const {return new PubSubJoinCall(*this);}
00181     virtual void parsimPack(cCommBuffer *b);
00182     virtual void parsimUnpack(cCommBuffer *b);
00183 
00184     // field getter/setter methods
00185     virtual Vector2D& getPosition();
00186     virtual const Vector2D& getPosition() const {return const_cast<PubSubJoinCall*>(this)->getPosition();}
00187     virtual void setPosition(const Vector2D& position_var);
00188     virtual int getRessources() const;
00189     virtual void setRessources(int ressources_var);
00190 };
00191 
00192 inline void doPacking(cCommBuffer *b, PubSubJoinCall& obj) {obj.parsimPack(b);}
00193 inline void doUnpacking(cCommBuffer *b, PubSubJoinCall& obj) {obj.parsimUnpack(b);}
00194 
00205 class PubSubJoinResponse : public BaseResponseMessage
00206 {
00207   protected:
00208     NodeHandle responsibleNode_var;
00209 
00210     // protected and unimplemented operator==(), to prevent accidental usage
00211     bool operator==(const PubSubJoinResponse&);
00212 
00213   public:
00214     PubSubJoinResponse(const char *name=NULL, int kind=0);
00215     PubSubJoinResponse(const PubSubJoinResponse& other);
00216     virtual ~PubSubJoinResponse();
00217     PubSubJoinResponse& operator=(const PubSubJoinResponse& other);
00218     virtual PubSubJoinResponse *dup() const {return new PubSubJoinResponse(*this);}
00219     virtual void parsimPack(cCommBuffer *b);
00220     virtual void parsimUnpack(cCommBuffer *b);
00221 
00222     // field getter/setter methods
00223     virtual NodeHandle& getResponsibleNode();
00224     virtual const NodeHandle& getResponsibleNode() const {return const_cast<PubSubJoinResponse*>(this)->getResponsibleNode();}
00225     virtual void setResponsibleNode(const NodeHandle& responsibleNode_var);
00226 };
00227 
00228 inline void doPacking(cCommBuffer *b, PubSubJoinResponse& obj) {obj.parsimPack(b);}
00229 inline void doUnpacking(cCommBuffer *b, PubSubJoinResponse& obj) {obj.parsimUnpack(b);}
00230 
00240 class PubSubResponsibleNodeCall : public BaseCallMessage
00241 {
00242   protected:
00243     Vector2D subspacePos_var;
00244 
00245     // protected and unimplemented operator==(), to prevent accidental usage
00246     bool operator==(const PubSubResponsibleNodeCall&);
00247 
00248   public:
00249     PubSubResponsibleNodeCall(const char *name=NULL, int kind=0);
00250     PubSubResponsibleNodeCall(const PubSubResponsibleNodeCall& other);
00251     virtual ~PubSubResponsibleNodeCall();
00252     PubSubResponsibleNodeCall& operator=(const PubSubResponsibleNodeCall& other);
00253     virtual PubSubResponsibleNodeCall *dup() const {return new PubSubResponsibleNodeCall(*this);}
00254     virtual void parsimPack(cCommBuffer *b);
00255     virtual void parsimUnpack(cCommBuffer *b);
00256 
00257     // field getter/setter methods
00258     virtual Vector2D& getSubspacePos();
00259     virtual const Vector2D& getSubspacePos() const {return const_cast<PubSubResponsibleNodeCall*>(this)->getSubspacePos();}
00260     virtual void setSubspacePos(const Vector2D& subspacePos_var);
00261 };
00262 
00263 inline void doPacking(cCommBuffer *b, PubSubResponsibleNodeCall& obj) {obj.parsimPack(b);}
00264 inline void doUnpacking(cCommBuffer *b, PubSubResponsibleNodeCall& obj) {obj.parsimUnpack(b);}
00265 
00276 class PubSubResponsibleNodeResponse : public BaseResponseMessage
00277 {
00278   protected:
00279     int subspaceId_var;
00280     NodeHandle responsibleNode_var;
00281 
00282     // protected and unimplemented operator==(), to prevent accidental usage
00283     bool operator==(const PubSubResponsibleNodeResponse&);
00284 
00285   public:
00286     PubSubResponsibleNodeResponse(const char *name=NULL, int kind=0);
00287     PubSubResponsibleNodeResponse(const PubSubResponsibleNodeResponse& other);
00288     virtual ~PubSubResponsibleNodeResponse();
00289     PubSubResponsibleNodeResponse& operator=(const PubSubResponsibleNodeResponse& other);
00290     virtual PubSubResponsibleNodeResponse *dup() const {return new PubSubResponsibleNodeResponse(*this);}
00291     virtual void parsimPack(cCommBuffer *b);
00292     virtual void parsimUnpack(cCommBuffer *b);
00293 
00294     // field getter/setter methods
00295     virtual int getSubspaceId() const;
00296     virtual void setSubspaceId(int subspaceId_var);
00297     virtual NodeHandle& getResponsibleNode();
00298     virtual const NodeHandle& getResponsibleNode() const {return const_cast<PubSubResponsibleNodeResponse*>(this)->getResponsibleNode();}
00299     virtual void setResponsibleNode(const NodeHandle& responsibleNode_var);
00300 };
00301 
00302 inline void doPacking(cCommBuffer *b, PubSubResponsibleNodeResponse& obj) {obj.parsimPack(b);}
00303 inline void doUnpacking(cCommBuffer *b, PubSubResponsibleNodeResponse& obj) {obj.parsimUnpack(b);}
00304 
00314 class PubSubTakeOverSubspaceCall : public BaseCallMessage
00315 {
00316   protected:
00317     Vector2D subspacePos_var;
00318 
00319     // protected and unimplemented operator==(), to prevent accidental usage
00320     bool operator==(const PubSubTakeOverSubspaceCall&);
00321 
00322   public:
00323     PubSubTakeOverSubspaceCall(const char *name=NULL, int kind=0);
00324     PubSubTakeOverSubspaceCall(const PubSubTakeOverSubspaceCall& other);
00325     virtual ~PubSubTakeOverSubspaceCall();
00326     PubSubTakeOverSubspaceCall& operator=(const PubSubTakeOverSubspaceCall& other);
00327     virtual PubSubTakeOverSubspaceCall *dup() const {return new PubSubTakeOverSubspaceCall(*this);}
00328     virtual void parsimPack(cCommBuffer *b);
00329     virtual void parsimUnpack(cCommBuffer *b);
00330 
00331     // field getter/setter methods
00332     virtual Vector2D& getSubspacePos();
00333     virtual const Vector2D& getSubspacePos() const {return const_cast<PubSubTakeOverSubspaceCall*>(this)->getSubspacePos();}
00334     virtual void setSubspacePos(const Vector2D& subspacePos_var);
00335 };
00336 
00337 inline void doPacking(cCommBuffer *b, PubSubTakeOverSubspaceCall& obj) {obj.parsimPack(b);}
00338 inline void doUnpacking(cCommBuffer *b, PubSubTakeOverSubspaceCall& obj) {obj.parsimUnpack(b);}
00339 
00349 class PubSubTakeOverSubspaceResponse : public BaseResponseMessage
00350 {
00351   protected:
00352     Vector2D subspacePos_var;
00353 
00354     // protected and unimplemented operator==(), to prevent accidental usage
00355     bool operator==(const PubSubTakeOverSubspaceResponse&);
00356 
00357   public:
00358     PubSubTakeOverSubspaceResponse(const char *name=NULL, int kind=0);
00359     PubSubTakeOverSubspaceResponse(const PubSubTakeOverSubspaceResponse& other);
00360     virtual ~PubSubTakeOverSubspaceResponse();
00361     PubSubTakeOverSubspaceResponse& operator=(const PubSubTakeOverSubspaceResponse& other);
00362     virtual PubSubTakeOverSubspaceResponse *dup() const {return new PubSubTakeOverSubspaceResponse(*this);}
00363     virtual void parsimPack(cCommBuffer *b);
00364     virtual void parsimUnpack(cCommBuffer *b);
00365 
00366     // field getter/setter methods
00367     virtual Vector2D& getSubspacePos();
00368     virtual const Vector2D& getSubspacePos() const {return const_cast<PubSubTakeOverSubspaceResponse*>(this)->getSubspacePos();}
00369     virtual void setSubspacePos(const Vector2D& subspacePos_var);
00370 };
00371 
00372 inline void doPacking(cCommBuffer *b, PubSubTakeOverSubspaceResponse& obj) {obj.parsimPack(b);}
00373 inline void doUnpacking(cCommBuffer *b, PubSubTakeOverSubspaceResponse& obj) {obj.parsimUnpack(b);}
00374 
00384 class PubSubSubscriptionCall : public BaseCallMessage
00385 {
00386   protected:
00387     int subspaceId_var;
00388 
00389     // protected and unimplemented operator==(), to prevent accidental usage
00390     bool operator==(const PubSubSubscriptionCall&);
00391 
00392   public:
00393     PubSubSubscriptionCall(const char *name=NULL, int kind=0);
00394     PubSubSubscriptionCall(const PubSubSubscriptionCall& other);
00395     virtual ~PubSubSubscriptionCall();
00396     PubSubSubscriptionCall& operator=(const PubSubSubscriptionCall& other);
00397     virtual PubSubSubscriptionCall *dup() const {return new PubSubSubscriptionCall(*this);}
00398     virtual void parsimPack(cCommBuffer *b);
00399     virtual void parsimUnpack(cCommBuffer *b);
00400 
00401     // field getter/setter methods
00402     virtual int getSubspaceId() const;
00403     virtual void setSubspaceId(int subspaceId_var);
00404 };
00405 
00406 inline void doPacking(cCommBuffer *b, PubSubSubscriptionCall& obj) {obj.parsimPack(b);}
00407 inline void doUnpacking(cCommBuffer *b, PubSubSubscriptionCall& obj) {obj.parsimUnpack(b);}
00408 
00418 class PubSubSubscriptionResponse : public BaseResponseMessage
00419 {
00420   protected:
00421     bool failed_var;
00422 
00423     // protected and unimplemented operator==(), to prevent accidental usage
00424     bool operator==(const PubSubSubscriptionResponse&);
00425 
00426   public:
00427     PubSubSubscriptionResponse(const char *name=NULL, int kind=0);
00428     PubSubSubscriptionResponse(const PubSubSubscriptionResponse& other);
00429     virtual ~PubSubSubscriptionResponse();
00430     PubSubSubscriptionResponse& operator=(const PubSubSubscriptionResponse& other);
00431     virtual PubSubSubscriptionResponse *dup() const {return new PubSubSubscriptionResponse(*this);}
00432     virtual void parsimPack(cCommBuffer *b);
00433     virtual void parsimUnpack(cCommBuffer *b);
00434 
00435     // field getter/setter methods
00436     virtual bool getFailed() const;
00437     virtual void setFailed(bool failed_var);
00438 };
00439 
00440 inline void doPacking(cCommBuffer *b, PubSubSubscriptionResponse& obj) {obj.parsimPack(b);}
00441 inline void doUnpacking(cCommBuffer *b, PubSubSubscriptionResponse& obj) {obj.parsimUnpack(b);}
00442 
00453 class PubSubUnsubscriptionMessage : public BaseOverlayMessage
00454 {
00455   protected:
00456     int subspaceId_var;
00457     NodeHandle src_var;
00458 
00459     // protected and unimplemented operator==(), to prevent accidental usage
00460     bool operator==(const PubSubUnsubscriptionMessage&);
00461 
00462   public:
00463     PubSubUnsubscriptionMessage(const char *name=NULL, int kind=0);
00464     PubSubUnsubscriptionMessage(const PubSubUnsubscriptionMessage& other);
00465     virtual ~PubSubUnsubscriptionMessage();
00466     PubSubUnsubscriptionMessage& operator=(const PubSubUnsubscriptionMessage& other);
00467     virtual PubSubUnsubscriptionMessage *dup() const {return new PubSubUnsubscriptionMessage(*this);}
00468     virtual void parsimPack(cCommBuffer *b);
00469     virtual void parsimUnpack(cCommBuffer *b);
00470 
00471     // field getter/setter methods
00472     virtual int getSubspaceId() const;
00473     virtual void setSubspaceId(int subspaceId_var);
00474     virtual NodeHandle& getSrc();
00475     virtual const NodeHandle& getSrc() const {return const_cast<PubSubUnsubscriptionMessage*>(this)->getSrc();}
00476     virtual void setSrc(const NodeHandle& src_var);
00477 };
00478 
00479 inline void doPacking(cCommBuffer *b, PubSubUnsubscriptionMessage& obj) {obj.parsimPack(b);}
00480 inline void doUnpacking(cCommBuffer *b, PubSubUnsubscriptionMessage& obj) {obj.parsimUnpack(b);}
00481 
00492 class PubSubHelpCall : public BaseCallMessage
00493 {
00494   protected:
00495     int subspaceId_var;
00496     int helpType_var;
00497 
00498     // protected and unimplemented operator==(), to prevent accidental usage
00499     bool operator==(const PubSubHelpCall&);
00500 
00501   public:
00502     PubSubHelpCall(const char *name=NULL, int kind=0);
00503     PubSubHelpCall(const PubSubHelpCall& other);
00504     virtual ~PubSubHelpCall();
00505     PubSubHelpCall& operator=(const PubSubHelpCall& other);
00506     virtual PubSubHelpCall *dup() const {return new PubSubHelpCall(*this);}
00507     virtual void parsimPack(cCommBuffer *b);
00508     virtual void parsimUnpack(cCommBuffer *b);
00509 
00510     // field getter/setter methods
00511     virtual int getSubspaceId() const;
00512     virtual void setSubspaceId(int subspaceId_var);
00513     virtual int getHelpType() const;
00514     virtual void setHelpType(int helpType_var);
00515 };
00516 
00517 inline void doPacking(cCommBuffer *b, PubSubHelpCall& obj) {obj.parsimPack(b);}
00518 inline void doUnpacking(cCommBuffer *b, PubSubHelpCall& obj) {obj.parsimUnpack(b);}
00519 
00531 class PubSubHelpResponse : public BaseResponseMessage
00532 {
00533   protected:
00534     int subspaceId_var;
00535     int helpType_var;
00536     NodeHandle node_var;
00537 
00538     // protected and unimplemented operator==(), to prevent accidental usage
00539     bool operator==(const PubSubHelpResponse&);
00540 
00541   public:
00542     PubSubHelpResponse(const char *name=NULL, int kind=0);
00543     PubSubHelpResponse(const PubSubHelpResponse& other);
00544     virtual ~PubSubHelpResponse();
00545     PubSubHelpResponse& operator=(const PubSubHelpResponse& other);
00546     virtual PubSubHelpResponse *dup() const {return new PubSubHelpResponse(*this);}
00547     virtual void parsimPack(cCommBuffer *b);
00548     virtual void parsimUnpack(cCommBuffer *b);
00549 
00550     // field getter/setter methods
00551     virtual int getSubspaceId() const;
00552     virtual void setSubspaceId(int subspaceId_var);
00553     virtual int getHelpType() const;
00554     virtual void setHelpType(int helpType_var);
00555     virtual NodeHandle& getNode();
00556     virtual const NodeHandle& getNode() const {return const_cast<PubSubHelpResponse*>(this)->getNode();}
00557     virtual void setNode(const NodeHandle& node_var);
00558 };
00559 
00560 inline void doPacking(cCommBuffer *b, PubSubHelpResponse& obj) {obj.parsimPack(b);}
00561 inline void doUnpacking(cCommBuffer *b, PubSubHelpResponse& obj) {obj.parsimUnpack(b);}
00562 
00572 class PubSubIntermediateCall : public BaseCallMessage
00573 {
00574   protected:
00575     int subspaceId_var;
00576 
00577     // protected and unimplemented operator==(), to prevent accidental usage
00578     bool operator==(const PubSubIntermediateCall&);
00579 
00580   public:
00581     PubSubIntermediateCall(const char *name=NULL, int kind=0);
00582     PubSubIntermediateCall(const PubSubIntermediateCall& other);
00583     virtual ~PubSubIntermediateCall();
00584     PubSubIntermediateCall& operator=(const PubSubIntermediateCall& other);
00585     virtual PubSubIntermediateCall *dup() const {return new PubSubIntermediateCall(*this);}
00586     virtual void parsimPack(cCommBuffer *b);
00587     virtual void parsimUnpack(cCommBuffer *b);
00588 
00589     // field getter/setter methods
00590     virtual int getSubspaceId() const;
00591     virtual void setSubspaceId(int subspaceId_var);
00592 };
00593 
00594 inline void doPacking(cCommBuffer *b, PubSubIntermediateCall& obj) {obj.parsimPack(b);}
00595 inline void doUnpacking(cCommBuffer *b, PubSubIntermediateCall& obj) {obj.parsimUnpack(b);}
00596 
00606 class PubSubIntermediateResponse : public BaseResponseMessage
00607 {
00608   protected:
00609     int subspaceId_var;
00610 
00611     // protected and unimplemented operator==(), to prevent accidental usage
00612     bool operator==(const PubSubIntermediateResponse&);
00613 
00614   public:
00615     PubSubIntermediateResponse(const char *name=NULL, int kind=0);
00616     PubSubIntermediateResponse(const PubSubIntermediateResponse& other);
00617     virtual ~PubSubIntermediateResponse();
00618     PubSubIntermediateResponse& operator=(const PubSubIntermediateResponse& other);
00619     virtual PubSubIntermediateResponse *dup() const {return new PubSubIntermediateResponse(*this);}
00620     virtual void parsimPack(cCommBuffer *b);
00621     virtual void parsimUnpack(cCommBuffer *b);
00622 
00623     // field getter/setter methods
00624     virtual int getSubspaceId() const;
00625     virtual void setSubspaceId(int subspaceId_var);
00626 };
00627 
00628 inline void doPacking(cCommBuffer *b, PubSubIntermediateResponse& obj) {obj.parsimPack(b);}
00629 inline void doUnpacking(cCommBuffer *b, PubSubIntermediateResponse& obj) {obj.parsimUnpack(b);}
00630 
00643 class PubSubBackupCall : public BaseCallMessage
00644 {
00645   protected:
00646     int subspaceId_var;
00647     NodeHandle *intermediates_var; // array ptr
00648     unsigned int intermediates_arraysize;
00649     NodeHandle *children_var; // array ptr
00650     unsigned int children_arraysize;
00651     int *childrenPos_var; // array ptr
00652     unsigned int childrenPos_arraysize;
00653 
00654     // protected and unimplemented operator==(), to prevent accidental usage
00655     bool operator==(const PubSubBackupCall&);
00656 
00657   public:
00658     PubSubBackupCall(const char *name=NULL, int kind=0);
00659     PubSubBackupCall(const PubSubBackupCall& other);
00660     virtual ~PubSubBackupCall();
00661     PubSubBackupCall& operator=(const PubSubBackupCall& other);
00662     virtual PubSubBackupCall *dup() const {return new PubSubBackupCall(*this);}
00663     virtual void parsimPack(cCommBuffer *b);
00664     virtual void parsimUnpack(cCommBuffer *b);
00665 
00666     // field getter/setter methods
00667     virtual int getSubspaceId() const;
00668     virtual void setSubspaceId(int subspaceId_var);
00669     virtual void setIntermediatesArraySize(unsigned int size);
00670     virtual unsigned int getIntermediatesArraySize() const;
00671     virtual NodeHandle& getIntermediates(unsigned int k);
00672     virtual const NodeHandle& getIntermediates(unsigned int k) const {return const_cast<PubSubBackupCall*>(this)->getIntermediates(k);}
00673     virtual void setIntermediates(unsigned int k, const NodeHandle& intermediates_var);
00674     virtual void setChildrenArraySize(unsigned int size);
00675     virtual unsigned int getChildrenArraySize() const;
00676     virtual NodeHandle& getChildren(unsigned int k);
00677     virtual const NodeHandle& getChildren(unsigned int k) const {return const_cast<PubSubBackupCall*>(this)->getChildren(k);}
00678     virtual void setChildren(unsigned int k, const NodeHandle& children_var);
00679     virtual void setChildrenPosArraySize(unsigned int size);
00680     virtual unsigned int getChildrenPosArraySize() const;
00681     virtual int getChildrenPos(unsigned int k) const;
00682     virtual void setChildrenPos(unsigned int k, int childrenPos_var);
00683 };
00684 
00685 inline void doPacking(cCommBuffer *b, PubSubBackupCall& obj) {obj.parsimPack(b);}
00686 inline void doUnpacking(cCommBuffer *b, PubSubBackupCall& obj) {obj.parsimUnpack(b);}
00687 
00697 class PubSubBackupResponse : public BaseResponseMessage
00698 {
00699   protected:
00700     int subspaceId_var;
00701 
00702     // protected and unimplemented operator==(), to prevent accidental usage
00703     bool operator==(const PubSubBackupResponse&);
00704 
00705   public:
00706     PubSubBackupResponse(const char *name=NULL, int kind=0);
00707     PubSubBackupResponse(const PubSubBackupResponse& other);
00708     virtual ~PubSubBackupResponse();
00709     PubSubBackupResponse& operator=(const PubSubBackupResponse& other);
00710     virtual PubSubBackupResponse *dup() const {return new PubSubBackupResponse(*this);}
00711     virtual void parsimPack(cCommBuffer *b);
00712     virtual void parsimUnpack(cCommBuffer *b);
00713 
00714     // field getter/setter methods
00715     virtual int getSubspaceId() const;
00716     virtual void setSubspaceId(int subspaceId_var);
00717 };
00718 
00719 inline void doPacking(cCommBuffer *b, PubSubBackupResponse& obj) {obj.parsimPack(b);}
00720 inline void doUnpacking(cCommBuffer *b, PubSubBackupResponse& obj) {obj.parsimUnpack(b);}
00721 
00732 class PubSubPingCall : public BaseCallMessage
00733 {
00734   protected:
00735     int subspaceId_var;
00736     int pingType_var;
00737 
00738     // protected and unimplemented operator==(), to prevent accidental usage
00739     bool operator==(const PubSubPingCall&);
00740 
00741   public:
00742     PubSubPingCall(const char *name=NULL, int kind=0);
00743     PubSubPingCall(const PubSubPingCall& other);
00744     virtual ~PubSubPingCall();
00745     PubSubPingCall& operator=(const PubSubPingCall& other);
00746     virtual PubSubPingCall *dup() const {return new PubSubPingCall(*this);}
00747     virtual void parsimPack(cCommBuffer *b);
00748     virtual void parsimUnpack(cCommBuffer *b);
00749 
00750     // field getter/setter methods
00751     virtual int getSubspaceId() const;
00752     virtual void setSubspaceId(int subspaceId_var);
00753     virtual int getPingType() const;
00754     virtual void setPingType(int pingType_var);
00755 };
00756 
00757 inline void doPacking(cCommBuffer *b, PubSubPingCall& obj) {obj.parsimPack(b);}
00758 inline void doUnpacking(cCommBuffer *b, PubSubPingCall& obj) {obj.parsimUnpack(b);}
00759 
00769 class PubSubPingResponse : public BaseResponseMessage
00770 {
00771   protected:
00772     int subspaceId_var;
00773 
00774     // protected and unimplemented operator==(), to prevent accidental usage
00775     bool operator==(const PubSubPingResponse&);
00776 
00777   public:
00778     PubSubPingResponse(const char *name=NULL, int kind=0);
00779     PubSubPingResponse(const PubSubPingResponse& other);
00780     virtual ~PubSubPingResponse();
00781     PubSubPingResponse& operator=(const PubSubPingResponse& other);
00782     virtual PubSubPingResponse *dup() const {return new PubSubPingResponse(*this);}
00783     virtual void parsimPack(cCommBuffer *b);
00784     virtual void parsimUnpack(cCommBuffer *b);
00785 
00786     // field getter/setter methods
00787     virtual int getSubspaceId() const;
00788     virtual void setSubspaceId(int subspaceId_var);
00789 };
00790 
00791 inline void doPacking(cCommBuffer *b, PubSubPingResponse& obj) {obj.parsimPack(b);}
00792 inline void doUnpacking(cCommBuffer *b, PubSubPingResponse& obj) {obj.parsimUnpack(b);}
00793 
00804 class PubSubReplacementMessage : public BaseOverlayMessage
00805 {
00806   protected:
00807     int subspaceId_var;
00808     NodeHandle newResponsibleNode_var;
00809 
00810     // protected and unimplemented operator==(), to prevent accidental usage
00811     bool operator==(const PubSubReplacementMessage&);
00812 
00813   public:
00814     PubSubReplacementMessage(const char *name=NULL, int kind=0);
00815     PubSubReplacementMessage(const PubSubReplacementMessage& other);
00816     virtual ~PubSubReplacementMessage();
00817     PubSubReplacementMessage& operator=(const PubSubReplacementMessage& other);
00818     virtual PubSubReplacementMessage *dup() const {return new PubSubReplacementMessage(*this);}
00819     virtual void parsimPack(cCommBuffer *b);
00820     virtual void parsimUnpack(cCommBuffer *b);
00821 
00822     // field getter/setter methods
00823     virtual int getSubspaceId() const;
00824     virtual void setSubspaceId(int subspaceId_var);
00825     virtual NodeHandle& getNewResponsibleNode();
00826     virtual const NodeHandle& getNewResponsibleNode() const {return const_cast<PubSubReplacementMessage*>(this)->getNewResponsibleNode();}
00827     virtual void setNewResponsibleNode(const NodeHandle& newResponsibleNode_var);
00828 };
00829 
00830 inline void doPacking(cCommBuffer *b, PubSubReplacementMessage& obj) {obj.parsimPack(b);}
00831 inline void doUnpacking(cCommBuffer *b, PubSubReplacementMessage& obj) {obj.parsimUnpack(b);}
00832 
00842 class PubSubFailedNodeMessage : public BaseOverlayMessage
00843 {
00844   protected:
00845     TransportAddress failedNode_var;
00846 
00847     // protected and unimplemented operator==(), to prevent accidental usage
00848     bool operator==(const PubSubFailedNodeMessage&);
00849 
00850   public:
00851     PubSubFailedNodeMessage(const char *name=NULL, int kind=0);
00852     PubSubFailedNodeMessage(const PubSubFailedNodeMessage& other);
00853     virtual ~PubSubFailedNodeMessage();
00854     PubSubFailedNodeMessage& operator=(const PubSubFailedNodeMessage& other);
00855     virtual PubSubFailedNodeMessage *dup() const {return new PubSubFailedNodeMessage(*this);}
00856     virtual void parsimPack(cCommBuffer *b);
00857     virtual void parsimUnpack(cCommBuffer *b);
00858 
00859     // field getter/setter methods
00860     virtual TransportAddress& getFailedNode();
00861     virtual const TransportAddress& getFailedNode() const {return const_cast<PubSubFailedNodeMessage*>(this)->getFailedNode();}
00862     virtual void setFailedNode(const TransportAddress& failedNode_var);
00863 };
00864 
00865 inline void doPacking(cCommBuffer *b, PubSubFailedNodeMessage& obj) {obj.parsimPack(b);}
00866 inline void doUnpacking(cCommBuffer *b, PubSubFailedNodeMessage& obj) {obj.parsimUnpack(b);}
00867 
00878 class PubSubNodeLeftMessage : public BaseOverlayMessage
00879 {
00880   protected:
00881     int subspaceId_var;
00882     NodeHandle node_var;
00883 
00884     // protected and unimplemented operator==(), to prevent accidental usage
00885     bool operator==(const PubSubNodeLeftMessage&);
00886 
00887   public:
00888     PubSubNodeLeftMessage(const char *name=NULL, int kind=0);
00889     PubSubNodeLeftMessage(const PubSubNodeLeftMessage& other);
00890     virtual ~PubSubNodeLeftMessage();
00891     PubSubNodeLeftMessage& operator=(const PubSubNodeLeftMessage& other);
00892     virtual PubSubNodeLeftMessage *dup() const {return new PubSubNodeLeftMessage(*this);}
00893     virtual void parsimPack(cCommBuffer *b);
00894     virtual void parsimUnpack(cCommBuffer *b);
00895 
00896     // field getter/setter methods
00897     virtual int getSubspaceId() const;
00898     virtual void setSubspaceId(int subspaceId_var);
00899     virtual NodeHandle& getNode();
00900     virtual const NodeHandle& getNode() const {return const_cast<PubSubNodeLeftMessage*>(this)->getNode();}
00901     virtual void setNode(const NodeHandle& node_var);
00902 };
00903 
00904 inline void doPacking(cCommBuffer *b, PubSubNodeLeftMessage& obj) {obj.parsimPack(b);}
00905 inline void doUnpacking(cCommBuffer *b, PubSubNodeLeftMessage& obj) {obj.parsimUnpack(b);}
00906 
00917 class PubSubAdoptChildCall : public BaseCallMessage
00918 {
00919   protected:
00920     int subspaceId_var;
00921     NodeHandle child_var;
00922 
00923     // protected and unimplemented operator==(), to prevent accidental usage
00924     bool operator==(const PubSubAdoptChildCall&);
00925 
00926   public:
00927     PubSubAdoptChildCall(const char *name=NULL, int kind=0);
00928     PubSubAdoptChildCall(const PubSubAdoptChildCall& other);
00929     virtual ~PubSubAdoptChildCall();
00930     PubSubAdoptChildCall& operator=(const PubSubAdoptChildCall& other);
00931     virtual PubSubAdoptChildCall *dup() const {return new PubSubAdoptChildCall(*this);}
00932     virtual void parsimPack(cCommBuffer *b);
00933     virtual void parsimUnpack(cCommBuffer *b);
00934 
00935     // field getter/setter methods
00936     virtual int getSubspaceId() const;
00937     virtual void setSubspaceId(int subspaceId_var);
00938     virtual NodeHandle& getChild();
00939     virtual const NodeHandle& getChild() const {return const_cast<PubSubAdoptChildCall*>(this)->getChild();}
00940     virtual void setChild(const NodeHandle& child_var);
00941 };
00942 
00943 inline void doPacking(cCommBuffer *b, PubSubAdoptChildCall& obj) {obj.parsimPack(b);}
00944 inline void doUnpacking(cCommBuffer *b, PubSubAdoptChildCall& obj) {obj.parsimUnpack(b);}
00945 
00956 class PubSubAdoptChildResponse : public BaseResponseMessage
00957 {
00958   protected:
00959     int subspaceId_var;
00960     NodeHandle child_var;
00961 
00962     // protected and unimplemented operator==(), to prevent accidental usage
00963     bool operator==(const PubSubAdoptChildResponse&);
00964 
00965   public:
00966     PubSubAdoptChildResponse(const char *name=NULL, int kind=0);
00967     PubSubAdoptChildResponse(const PubSubAdoptChildResponse& other);
00968     virtual ~PubSubAdoptChildResponse();
00969     PubSubAdoptChildResponse& operator=(const PubSubAdoptChildResponse& other);
00970     virtual PubSubAdoptChildResponse *dup() const {return new PubSubAdoptChildResponse(*this);}
00971     virtual void parsimPack(cCommBuffer *b);
00972     virtual void parsimUnpack(cCommBuffer *b);
00973 
00974     // field getter/setter methods
00975     virtual int getSubspaceId() const;
00976     virtual void setSubspaceId(int subspaceId_var);
00977     virtual NodeHandle& getChild();
00978     virtual const NodeHandle& getChild() const {return const_cast<PubSubAdoptChildResponse*>(this)->getChild();}
00979     virtual void setChild(const NodeHandle& child_var);
00980 };
00981 
00982 inline void doPacking(cCommBuffer *b, PubSubAdoptChildResponse& obj) {obj.parsimPack(b);}
00983 inline void doUnpacking(cCommBuffer *b, PubSubAdoptChildResponse& obj) {obj.parsimUnpack(b);}
00984 
00994 class PubSubReleaseIntermediateMessage : public BaseOverlayMessage
00995 {
00996   protected:
00997     int subspaceId_var;
00998 
00999     // protected and unimplemented operator==(), to prevent accidental usage
01000     bool operator==(const PubSubReleaseIntermediateMessage&);
01001 
01002   public:
01003     PubSubReleaseIntermediateMessage(const char *name=NULL, int kind=0);
01004     PubSubReleaseIntermediateMessage(const PubSubReleaseIntermediateMessage& other);
01005     virtual ~PubSubReleaseIntermediateMessage();
01006     PubSubReleaseIntermediateMessage& operator=(const PubSubReleaseIntermediateMessage& other);
01007     virtual PubSubReleaseIntermediateMessage *dup() const {return new PubSubReleaseIntermediateMessage(*this);}
01008     virtual void parsimPack(cCommBuffer *b);
01009     virtual void parsimUnpack(cCommBuffer *b);
01010 
01011     // field getter/setter methods
01012     virtual int getSubspaceId() const;
01013     virtual void setSubspaceId(int subspaceId_var);
01014 };
01015 
01016 inline void doPacking(cCommBuffer *b, PubSubReleaseIntermediateMessage& obj) {obj.parsimPack(b);}
01017 inline void doUnpacking(cCommBuffer *b, PubSubReleaseIntermediateMessage& obj) {obj.parsimUnpack(b);}
01018 
01029 class PubSubHelpReleaseMessage : public BaseOverlayMessage
01030 {
01031   protected:
01032     int subspaceId_var;
01033     NodeHandle node_var;
01034 
01035     // protected and unimplemented operator==(), to prevent accidental usage
01036     bool operator==(const PubSubHelpReleaseMessage&);
01037 
01038   public:
01039     PubSubHelpReleaseMessage(const char *name=NULL, int kind=0);
01040     PubSubHelpReleaseMessage(const PubSubHelpReleaseMessage& other);
01041     virtual ~PubSubHelpReleaseMessage();
01042     PubSubHelpReleaseMessage& operator=(const PubSubHelpReleaseMessage& other);
01043     virtual PubSubHelpReleaseMessage *dup() const {return new PubSubHelpReleaseMessage(*this);}
01044     virtual void parsimPack(cCommBuffer *b);
01045     virtual void parsimUnpack(cCommBuffer *b);
01046 
01047     // field getter/setter methods
01048     virtual int getSubspaceId() const;
01049     virtual void setSubspaceId(int subspaceId_var);
01050     virtual NodeHandle& getNode();
01051     virtual const NodeHandle& getNode() const {return const_cast<PubSubHelpReleaseMessage*>(this)->getNode();}
01052     virtual void setNode(const NodeHandle& node_var);
01053 };
01054 
01055 inline void doPacking(cCommBuffer *b, PubSubHelpReleaseMessage& obj) {obj.parsimPack(b);}
01056 inline void doUnpacking(cCommBuffer *b, PubSubHelpReleaseMessage& obj) {obj.parsimUnpack(b);}
01057 
01070 class PubSubBackupSubscriptionMessage : public BaseOverlayMessage
01071 {
01072   protected:
01073     int subspaceId_var;
01074     NodeHandle child_var;
01075     NodeHandle parent_var;
01076     NodeHandle oldParent_var;
01077 
01078     // protected and unimplemented operator==(), to prevent accidental usage
01079     bool operator==(const PubSubBackupSubscriptionMessage&);
01080 
01081   public:
01082     PubSubBackupSubscriptionMessage(const char *name=NULL, int kind=0);
01083     PubSubBackupSubscriptionMessage(const PubSubBackupSubscriptionMessage& other);
01084     virtual ~PubSubBackupSubscriptionMessage();
01085     PubSubBackupSubscriptionMessage& operator=(const PubSubBackupSubscriptionMessage& other);
01086     virtual PubSubBackupSubscriptionMessage *dup() const {return new PubSubBackupSubscriptionMessage(*this);}
01087     virtual void parsimPack(cCommBuffer *b);
01088     virtual void parsimUnpack(cCommBuffer *b);
01089 
01090     // field getter/setter methods
01091     virtual int getSubspaceId() const;
01092     virtual void setSubspaceId(int subspaceId_var);
01093     virtual NodeHandle& getChild();
01094     virtual const NodeHandle& getChild() const {return const_cast<PubSubBackupSubscriptionMessage*>(this)->getChild();}
01095     virtual void setChild(const NodeHandle& child_var);
01096     virtual NodeHandle& getParent();
01097     virtual const NodeHandle& getParent() const {return const_cast<PubSubBackupSubscriptionMessage*>(this)->getParent();}
01098     virtual void setParent(const NodeHandle& parent_var);
01099     virtual NodeHandle& getOldParent();
01100     virtual const NodeHandle& getOldParent() const {return const_cast<PubSubBackupSubscriptionMessage*>(this)->getOldParent();}
01101     virtual void setOldParent(const NodeHandle& oldParent_var);
01102 };
01103 
01104 inline void doPacking(cCommBuffer *b, PubSubBackupSubscriptionMessage& obj) {obj.parsimPack(b);}
01105 inline void doUnpacking(cCommBuffer *b, PubSubBackupSubscriptionMessage& obj) {obj.parsimUnpack(b);}
01106 
01118 class PubSubBackupIntermediateMessage : public BaseOverlayMessage
01119 {
01120   protected:
01121     int subspaceId_var;
01122     NodeHandle node_var;
01123     int pos_var;
01124 
01125     // protected and unimplemented operator==(), to prevent accidental usage
01126     bool operator==(const PubSubBackupIntermediateMessage&);
01127 
01128   public:
01129     PubSubBackupIntermediateMessage(const char *name=NULL, int kind=0);
01130     PubSubBackupIntermediateMessage(const PubSubBackupIntermediateMessage& other);
01131     virtual ~PubSubBackupIntermediateMessage();
01132     PubSubBackupIntermediateMessage& operator=(const PubSubBackupIntermediateMessage& other);
01133     virtual PubSubBackupIntermediateMessage *dup() const {return new PubSubBackupIntermediateMessage(*this);}
01134     virtual void parsimPack(cCommBuffer *b);
01135     virtual void parsimUnpack(cCommBuffer *b);
01136 
01137     // field getter/setter methods
01138     virtual int getSubspaceId() const;
01139     virtual void setSubspaceId(int subspaceId_var);
01140     virtual NodeHandle& getNode();
01141     virtual const NodeHandle& getNode() const {return const_cast<PubSubBackupIntermediateMessage*>(this)->getNode();}
01142     virtual void setNode(const NodeHandle& node_var);
01143     virtual int getPos() const;
01144     virtual void setPos(int pos_var);
01145 };
01146 
01147 inline void doPacking(cCommBuffer *b, PubSubBackupIntermediateMessage& obj) {obj.parsimPack(b);}
01148 inline void doUnpacking(cCommBuffer *b, PubSubBackupIntermediateMessage& obj) {obj.parsimUnpack(b);}
01149 
01161 class PubSubBackupUnsubscribeMessage : public BaseOverlayMessage
01162 {
01163   protected:
01164     int subspaceId_var;
01165     NodeHandle child_var;
01166     NodeHandle intermediate_var;
01167 
01168     // protected and unimplemented operator==(), to prevent accidental usage
01169     bool operator==(const PubSubBackupUnsubscribeMessage&);
01170 
01171   public:
01172     PubSubBackupUnsubscribeMessage(const char *name=NULL, int kind=0);
01173     PubSubBackupUnsubscribeMessage(const PubSubBackupUnsubscribeMessage& other);
01174     virtual ~PubSubBackupUnsubscribeMessage();
01175     PubSubBackupUnsubscribeMessage& operator=(const PubSubBackupUnsubscribeMessage& other);
01176     virtual PubSubBackupUnsubscribeMessage *dup() const {return new PubSubBackupUnsubscribeMessage(*this);}
01177     virtual void parsimPack(cCommBuffer *b);
01178     virtual void parsimUnpack(cCommBuffer *b);
01179 
01180     // field getter/setter methods
01181     virtual int getSubspaceId() const;
01182     virtual void setSubspaceId(int subspaceId_var);
01183     virtual NodeHandle& getChild();
01184     virtual const NodeHandle& getChild() const {return const_cast<PubSubBackupUnsubscribeMessage*>(this)->getChild();}
01185     virtual void setChild(const NodeHandle& child_var);
01186     virtual NodeHandle& getIntermediate();
01187     virtual const NodeHandle& getIntermediate() const {return const_cast<PubSubBackupUnsubscribeMessage*>(this)->getIntermediate();}
01188     virtual void setIntermediate(const NodeHandle& intermediate_var);
01189 };
01190 
01191 inline void doPacking(cCommBuffer *b, PubSubBackupUnsubscribeMessage& obj) {obj.parsimPack(b);}
01192 inline void doUnpacking(cCommBuffer *b, PubSubBackupUnsubscribeMessage& obj) {obj.parsimUnpack(b);}
01193 
01206 class PubSubMoveMessage : public BaseOverlayMessage
01207 {
01208   protected:
01209     int subspaceId_var;
01210     simtime_t timestamp_var;
01211     NodeHandle player_var;
01212     Vector2D position_var;
01213 
01214     // protected and unimplemented operator==(), to prevent accidental usage
01215     bool operator==(const PubSubMoveMessage&);
01216 
01217   public:
01218     PubSubMoveMessage(const char *name=NULL, int kind=0);
01219     PubSubMoveMessage(const PubSubMoveMessage& other);
01220     virtual ~PubSubMoveMessage();
01221     PubSubMoveMessage& operator=(const PubSubMoveMessage& other);
01222     virtual PubSubMoveMessage *dup() const {return new PubSubMoveMessage(*this);}
01223     virtual void parsimPack(cCommBuffer *b);
01224     virtual void parsimUnpack(cCommBuffer *b);
01225 
01226     // field getter/setter methods
01227     virtual int getSubspaceId() const;
01228     virtual void setSubspaceId(int subspaceId_var);
01229     virtual simtime_t getTimestamp() const;
01230     virtual void setTimestamp(simtime_t timestamp_var);
01231     virtual NodeHandle& getPlayer();
01232     virtual const NodeHandle& getPlayer() const {return const_cast<PubSubMoveMessage*>(this)->getPlayer();}
01233     virtual void setPlayer(const NodeHandle& player_var);
01234     virtual Vector2D& getPosition();
01235     virtual const Vector2D& getPosition() const {return const_cast<PubSubMoveMessage*>(this)->getPosition();}
01236     virtual void setPosition(const Vector2D& position_var);
01237 };
01238 
01239 inline void doPacking(cCommBuffer *b, PubSubMoveMessage& obj) {obj.parsimPack(b);}
01240 inline void doUnpacking(cCommBuffer *b, PubSubMoveMessage& obj) {obj.parsimUnpack(b);}
01241 
01255 class PubSubMoveListMessage : public BaseOverlayMessage
01256 {
01257   protected:
01258     int subspaceId_var;
01259     simtime_t timestamp_var;
01260     NodeHandle *player_var; // array ptr
01261     unsigned int player_arraysize;
01262     Vector2D *position_var; // array ptr
01263     unsigned int position_arraysize;
01264     simtime_t *positionAge_var; // array ptr
01265     unsigned int positionAge_arraysize;
01266 
01267     // protected and unimplemented operator==(), to prevent accidental usage
01268     bool operator==(const PubSubMoveListMessage&);
01269 
01270   public:
01271     PubSubMoveListMessage(const char *name=NULL, int kind=0);
01272     PubSubMoveListMessage(const PubSubMoveListMessage& other);
01273     virtual ~PubSubMoveListMessage();
01274     PubSubMoveListMessage& operator=(const PubSubMoveListMessage& other);
01275     virtual PubSubMoveListMessage *dup() const {return new PubSubMoveListMessage(*this);}
01276     virtual void parsimPack(cCommBuffer *b);
01277     virtual void parsimUnpack(cCommBuffer *b);
01278 
01279     // field getter/setter methods
01280     virtual int getSubspaceId() const;
01281     virtual void setSubspaceId(int subspaceId_var);
01282     virtual simtime_t getTimestamp() const;
01283     virtual void setTimestamp(simtime_t timestamp_var);
01284     virtual void setPlayerArraySize(unsigned int size);
01285     virtual unsigned int getPlayerArraySize() const;
01286     virtual NodeHandle& getPlayer(unsigned int k);
01287     virtual const NodeHandle& getPlayer(unsigned int k) const {return const_cast<PubSubMoveListMessage*>(this)->getPlayer(k);}
01288     virtual void setPlayer(unsigned int k, const NodeHandle& player_var);
01289     virtual void setPositionArraySize(unsigned int size);
01290     virtual unsigned int getPositionArraySize() const;
01291     virtual Vector2D& getPosition(unsigned int k);
01292     virtual const Vector2D& getPosition(unsigned int k) const {return const_cast<PubSubMoveListMessage*>(this)->getPosition(k);}
01293     virtual void setPosition(unsigned int k, const Vector2D& position_var);
01294     virtual void setPositionAgeArraySize(unsigned int size);
01295     virtual unsigned int getPositionAgeArraySize() const;
01296     virtual simtime_t getPositionAge(unsigned int k) const;
01297     virtual void setPositionAge(unsigned int k, simtime_t positionAge_var);
01298 };
01299 
01300 inline void doPacking(cCommBuffer *b, PubSubMoveListMessage& obj) {obj.parsimPack(b);}
01301 inline void doUnpacking(cCommBuffer *b, PubSubMoveListMessage& obj) {obj.parsimUnpack(b);}
01302 
01303 
01304 #endif // _PUBSUBMESSAGE_M_H_

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