Changeset 5929 for code/trunk/src/libraries/network/synchronisable

Timestamp:

Oct 12, 2009, 8:20:07 PM (15 years ago)

Author:

rgrieder

Message:

Merged core5 branch back to the trunk.
Key features include clean level unloading and an extended XML event system.

Two important notes:
Delete your keybindings.ini files! * or you will still get parser errors when loading the key bindings.
Delete build_dir/lib/modules/libgamestates.module! * or orxonox won't start.
Best thing to do is to delete the build folder

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/network/synchronisable/Synchronisable.cc (modified) (20 diffs)
• src/libraries/network/synchronisable/Synchronisable.h (modified) (5 diffs)

code/trunk/src/libraries/network/synchronisable/Synchronisable.cc

@@ -47 +47 @@
   /**
   * Constructor:
-  * Initializes all Variables and sets the right objectID
+  * Initializes all Variables and sets the right objectID_
   */
-  Synchronisable::Synchronisable(BaseObject* creator){
+  Synchronisable::Synchronisable(BaseObject* creator ){
     RegisterRootObject(Synchronisable);
     static uint32_t idCounter=0;
@@ -55 +55 @@
     if ( GameMode::isMaster() || ( Host::running() && Host::isServer() ) )
     {
-      this->objectID = idCounter++; //this is only needed when running a server
-    //add synchronisable to the objectMap
-      objectMap_[this->objectID] = this;
+      this->setObjectID( idCounter++ );
     }
     else
     {
-      objectID=OBJECTID_UNKNOWN;
-      this->setObjectMode(0x0);   //make sure this object doesn't get synchronized
-    }
-    classID = static_cast<uint32_t>(-1);
+      objectID_=OBJECTID_UNKNOWN;
+    }
+    classID_ = static_cast<uint32_t>(-1);
     
     // set dataSize to 0
@@ -72 +69 @@
 
     // get creator id
-    this->creatorID = OBJECTID_UNKNOWN;
-
-    searchcreatorID:
+    if( creator )
+      this->creatorID_ = creator->getSceneID();
+    else
+      this->creatorID_ = OBJECTID_UNKNOWN;
+
+    /*searchcreatorID:
     if (creator)
     {
@@ -80 +80 @@
         if (synchronisable_creator && synchronisable_creator->objectMode_)
         {
-            this->creatorID = synchronisable_creator->getObjectID();
+            this->creatorID = synchronisable_creator->getScene()->getObjectID();
         }
         else if (creator != creator->getCreator())
@@ -87 +87 @@
             goto searchcreatorID;
         }
-    }
+    }*/
   }
 
   /**
    * Destructor:
-   * Delete all callback objects and remove objectID from the objectMap_
+   * Delete all callback objects and remove objectID_ from the objectMap_
    */
   Synchronisable::~Synchronisable(){
@@ -99 +99 @@
       // remove object from the static objectMap
       if (this->objectMode_ != 0x0 && (Host::running() && Host::isServer()))
-        deletedObjects_.push(objectID);
+        deletedObjects_.push(objectID_);
     }
     // delete all Synchronisable Variables from syncList ( which are also in stringList )
@@ -107 +107 @@
     stringList.clear();
     std::map<uint32_t, Synchronisable*>::iterator it;
-    it = objectMap_.find(objectID);
+    it = objectMap_.find(objectID_);
     if (it != objectMap_.end())
       objectMap_.erase(it);
@@ -172 +172 @@
     Synchronisable *no = orxonox_cast<Synchronisable*>(bo);
     assert(no);
-    no->objectID=header.getObjectID();
-    no->creatorID=header.getCreatorID(); //TODO: remove this
-    no->classID=header.getClassID();
-    COUT(4) << "fabricate objectID: " << no->objectID << " classID: " << no->classID << std::endl;
+    assert( Synchronisable::objectMap_.find(header.getObjectID()) == Synchronisable::objectMap_.end() );
+    no->setObjectID(header.getObjectID());
+    //no->creatorID=header.getCreatorID(); //TODO: remove this
+    no->setClassID(header.getClassID());
+    assert(no->creatorID_ == header.getCreatorID());
+    //assert(no->classID_ == header.getClassID());
+    COUT(4) << "fabricate objectID_: " << no->objectID_ << " classID_: " << no->classID_ << std::endl;
           // update data and create object/entity...
-    assert( Synchronisable::objectMap_.find(header.getObjectID()) == Synchronisable::objectMap_.end() );
-    Synchronisable::objectMap_[header.getObjectID()] = no;
     bool b = no->updateData(mem, mode, true);
     assert(b);
@@ -191 +192 @@
 
   /**
-   * Finds and deletes the Synchronisable with the appropriate objectID
-   * @param objectID objectID of the Synchronisable
+   * Finds and deletes the Synchronisable with the appropriate objectID_
+   * @param objectID_ objectID_ of the Synchronisable
    * @return true/false
    */
-  bool Synchronisable::deleteObject(uint32_t objectID){
-    if(!getSynchronisable(objectID))
+  bool Synchronisable::deleteObject(uint32_t objectID_){
+    if(!getSynchronisable(objectID_))
       return false;
-    assert(getSynchronisable(objectID)->objectID==objectID);
-    Synchronisable *s = getSynchronisable(objectID);
+    assert(getSynchronisable(objectID_)->objectID_==objectID_);
+    Synchronisable *s = getSynchronisable(objectID_);
     if(s)
-      delete s;
+      s->destroy(); // or delete?
     else
       return false;
@@ -208 +209 @@
 
   /**
-   * This function looks up the objectID in the objectMap_ and returns a pointer to the right Synchronisable
-   * @param objectID objectID of the Synchronisable
-   * @return pointer to the Synchronisable with the objectID
-   */
-  Synchronisable* Synchronisable::getSynchronisable(uint32_t objectID){
+   * This function looks up the objectID_ in the objectMap_ and returns a pointer to the right Synchronisable
+   * @param objectID_ objectID_ of the Synchronisable
+   * @return pointer to the Synchronisable with the objectID_
+   */
+  Synchronisable* Synchronisable::getSynchronisable(uint32_t objectID_){
     std::map<uint32_t, Synchronisable*>::iterator it1;
-    it1 = objectMap_.find(objectID);
+    it1 = objectMap_.find(objectID_);
     if (it1 != objectMap_.end())
       return it1->second;
@@ -220 +221 @@
 //     ObjectList<Synchronisable>::iterator it;
 //     for(it = ObjectList<Synchronisable>::begin(); it; ++it){
-//       if( it->getObjectID()==objectID ){
-//         objectMap_[objectID] = *it;
+//       if( it->getObjectID()==objectID_ ){
+//         objectMap_[objectID_] = *it;
 //         return *it;
 //       }
@@ -231 +232 @@
 
   /**
-   * This function takes all SynchronisableVariables out of the Synchronisable and saves them together with the size, objectID and classID to the given memory
+   * This function takes all SynchronisableVariables out of the Synchronisable and saves them together with the size, objectID_ and classID_ to the given memory
    * takes a pointer to already allocated memory (must have at least getSize bytes length)
    * structure of the bitstream:
-   * |totalsize,objectID,classID,var1,var2,string1_length,string1,var3,...|
+   * |totalsize,objectID_,classID_,var1,var2,string1_length,string1,var3,...|
    * length of varx: size saved int syncvarlist
    * @param mem pointer to allocated memory with enough size
@@ -252 +253 @@
     uint32_t tempsize = 0;
 #ifndef NDEBUG
-    if (this->classID==0)
+    if (this->classID_==0)
       COUT(3) << "classid 0 " << this->getIdentifier()->getName() << std::endl;
 #endif
 
-    if (this->classID == static_cast<uint32_t>(-1))
-        this->classID = this->getIdentifier()->getNetworkID();
-
-    assert(ClassByID(this->classID));
-    assert(this->classID==this->getIdentifier()->getNetworkID());
+    if (this->classID_ == static_cast<uint32_t>(-1))
+        this->classID_ = this->getIdentifier()->getNetworkID();
+
+    assert(ClassByID(this->classID_));
+    assert(this->classID_==this->getIdentifier()->getNetworkID());
+    assert(this->objectID_!=OBJECTID_UNKNOWN);
     std::vector<SynchronisableVariableBase*>::iterator i;
 
@@ -269 +271 @@
 
 
-    COUT(5) << "Synchronisable getting data from objectID: " << objectID << " classID: " << classID << std::endl;
+    COUT(5) << "Synchronisable getting data from objectID_: " << objectID_ << " classID_: " << classID_ << std::endl;
     // copy to location
     for(i=syncList.begin(); i!=syncList.end(); ++i){
@@ -277 +279 @@
     
     tempsize += SynchronisableHeader::getSize();
-    header.setObjectID( this->objectID );
-    header.setCreatorID( this->creatorID );
-    header.setClassID( this->classID );
+    header.setObjectID( this->objectID_ );
+    header.setCreatorID( this->creatorID_ );
+    header.setClassID( this->classID_ );
     header.setDataAvailable( true );
     header.setDataSize( tempsize );
@@ -311 +313 @@
     // start extract header
     SynchronisableHeader syncHeader(mem);
-    assert(syncHeader.getObjectID()==this->objectID);
-    assert(syncHeader.getCreatorID()==this->creatorID);
-    assert(syncHeader.getClassID()==this->classID);
+    assert(syncHeader.getObjectID()==this->objectID_);
+    assert(syncHeader.getCreatorID()==this->creatorID_);
+    assert(syncHeader.getClassID()==this->classID_);
     if(syncHeader.isDataAvailable()==false){
       mem += syncHeader.getDataSize();
@@ -322 +324 @@
     // stop extract header
 
-    //COUT(5) << "Synchronisable: objectID " << syncHeader.getObjectID() << ", classID " << syncHeader.getClassID() << " size: " << syncHeader.getDataSize() << " synchronising data" << std::endl;
+    //COUT(5) << "Synchronisable: objectID_ " << syncHeader.getObjectID() << ", classID_ " << syncHeader.getClassID() << " size: " << syncHeader.getDataSize() << " synchronising data" << std::endl;
     for(i=syncList.begin(); i!=syncList.end(); i++)
     {
@@ -361 +363 @@
     if(mode==0x0)
       mode=state_;
-    return ( (objectMode_&mode)!=0 && (!syncList.empty() ) );
-  }
-
-  /**
-   * This function looks at the header located in the bytestream and checks wheter objectID and classID match with the Synchronisables ones
+    return ( (this->objectMode_ & mode)!=0 && (!syncList.empty() ) );
+  }
+
+  /**
+   * This function looks at the header located in the bytestream and checks wheter objectID_ and classID_ match with the Synchronisables ones
    * @param mem pointer to the bytestream
    */
@@ -371 +373 @@
   {
     SynchronisableHeader header(mem);
-    assert(header.getObjectID()==this->objectID);
+    assert(header.getObjectID()==this->objectID_);
     return header.isDataAvailable();
   }
@@ -383 +385 @@
    * @param mode same as in registerVar
    */
-  void Synchronisable::setObjectMode(uint8_t mode){
+  void Synchronisable::setSyncMode(uint8_t mode){
     assert(mode==0x0 || mode==0x1 || mode==0x2 || mode==0x3);
-    objectMode_=mode;
+    this->objectMode_=mode;
   }
 

code/trunk/src/libraries/network/synchronisable/Synchronisable.h

@@ -68 +68 @@
    * @brief: stores information about a Synchronisable 
    * 
-   * This class stores the information about a Synchronisable (objectID, classID, creatorID, dataSize)
+   * This class stores the information about a Synchronisable (objectID_, classID_, creatorID_, dataSize)
    * in an emulated bitset.
    * Bit 1 to 31 store the size of the Data the synchronisable consumes in the stream
    * Bit 32 is a bool and defines whether the data is actually stored or is just filled up with 0
-   * Byte 5 to 8: objectID
-   * Byte 9 to 12: classID
-   * Byte 13 to 16: creatorID
+   * Byte 5 to 8: objectID_
+   * Byte 9 to 12: classID_
+   * Byte 13 to 16: creatorID_
    */
   class _NetworkExport SynchronisableHeader{
@@ -94 +94 @@
       inline uint32_t getObjectID() const
         { return *(uint32_t*)(data_+4); }
-      inline void setObjectID(uint32_t objectID)
-        { *(uint32_t*)(data_+4) = objectID; }
+      inline void setObjectID(uint32_t objectID_)
+        { *(uint32_t*)(data_+4) = objectID_; }
       inline uint32_t getClassID() const
         { return *(uint32_t*)(data_+8); }
-      inline void setClassID(uint32_t classID)
-        { *(uint32_t*)(data_+8) = classID; }
+      inline void setClassID(uint32_t classID_)
+        { *(uint32_t*)(data_+8) = classID_; }
       inline uint32_t getCreatorID() const
         { return *(uint32_t*)(data_+12); }
-      inline void setCreatorID(uint32_t creatorID)
-        { *(uint32_t*)(data_+12) = creatorID; }
+      inline void setCreatorID(uint32_t creatorID_)
+        { *(uint32_t*)(data_+12) = creatorID_; }
       inline void operator=(SynchronisableHeader& h)
         { memcpy(data_, h.data_, getSize()); }
@@ -122 +122 @@
 
     static Synchronisable *fabricate(uint8_t*& mem, uint8_t mode=0x0);
-    static bool deleteObject(uint32_t objectID);
-    static Synchronisable *getSynchronisable(uint32_t objectID);
+    static bool deleteObject(uint32_t objectID_);
+    static Synchronisable *getSynchronisable(uint32_t objectID_);
     static unsigned int getNumberOfDeletedObject(){ return deletedObjects_.size(); }
     static uint32_t popDeletedObject(){ uint32_t i = deletedObjects_.front(); deletedObjects_.pop(); return i; }
 
-    inline uint32_t getObjectID() const {return objectID;}
-    inline unsigned int getCreatorID() const {return creatorID;}
-    inline uint32_t getClassID() const {return classID;}
-    inline unsigned int getPriority() const { return objectFrequency_;}
+    inline uint32_t getObjectID() const {return this->objectID_;}
+    inline unsigned int getCreatorID() const {return this->creatorID_;}
+    inline uint32_t getClassID() const {return this->classID_;}
+    inline unsigned int getPriority() const { return this->objectFrequency_;}
+    inline uint8_t getSyncMode() const { return this->objectMode_; }
+    
+    void setSyncMode(uint8_t mode);
 
   protected:
@@ -136 +139 @@
     template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
     //template <class T> void unregisterVariable(T& var);
-    void setObjectMode(uint8_t mode);
     void setPriority(unsigned int freq){ objectFrequency_ = freq; }
 
@@ -146 +148 @@
     bool isMyData(uint8_t* mem);
     bool doSync(int32_t id, uint8_t mode=0x0);
-
-    uint32_t objectID;
-    uint32_t creatorID;
-    uint32_t classID;
+    
+    inline void setObjectID(uint32_t id){ this->objectID_ = id; objectMap_[this->objectID_] = this; }
+    inline void setClassID(uint32_t id){ this->classID_ = id; }
+
+    uint32_t objectID_;
+    uint32_t creatorID_;
+    uint32_t classID_;
 
     std::vector<SynchronisableVariableBase*> syncList;