Changeset 2309 for code/branches/network64/src/network/synchronisable

Timestamp:

Dec 2, 2008, 9:10:00 PM (16 years ago)

Author:

scheusso

Message:

made some adjustments mostly to the networkid (classid) in order to have it platform independent

Location:

code/branches/network64/src/network/synchronisable

Files:

• CMakeLists.txt (modified) (1 diff)
• NetworkCallback.h (modified) (2 diffs)
• Synchronisable.cc (modified) (11 diffs)
• Synchronisable.h (modified) (4 diffs)
• SynchronisableSpecialisations.cc (modified) (5 diffs)
• SynchronisableVariable.cc (modified) (1 diff)
• SynchronisableVariable.h (modified) (4 diffs)

code/branches/network64/src/network/synchronisable/CMakeLists.txt

@@ -1 +1 @@
 SET( SRC_FILES
+  NetworkCallbackManager.cc
   Synchronisable.cc
   SynchronisableSpecialisations.cc

code/branches/network64/src/network/synchronisable/NetworkCallback.h

@@ +1 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Oliver Scheuss, (C) 2008
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+
 #ifndef _NETWORK_CALLBACK__
 #define _NETWORK_CALLBACK__
 
 #include "network/NetworkPrereqs.h"
+#include "NetworkCallbackManager.h"
 
 namespace orxonox{
+  
   class _NetworkExport NetworkCallbackBase
   {
     public:
       virtual void call() = 0;
-          virtual ~NetworkCallbackBase() {}
+      NetworkCallbackBase(){ NetworkCallbackManager::registerCallback( this ); }
+      virtual ~NetworkCallbackBase() {}
   };
 
@@ -26 +58 @@
   };
 
-
 }
 

code/branches/network64/src/network/synchronisable/Synchronisable.cc

@@ -55 +55 @@
 
 
-  std::map<unsigned int, Synchronisable *> Synchronisable::objectMap_;
-  std::queue<unsigned int> Synchronisable::deletedObjects_;
+  std::map<uint32_t, Synchronisable *> Synchronisable::objectMap_;
+  std::queue<uint32_t> Synchronisable::deletedObjects_;
 
   uint8_t Synchronisable::state_=0x1; // detemines wheter we are server (default) or client
@@ -77 +77 @@
     else
       objectID=OBJECTID_UNKNOWN;
-    classID = (unsigned int)-1;
+    classID = static_cast<uint32_t>(-1);
 
 
@@ -122 +122 @@
 //       objectMap_.erase(objectID);
     }
-    std::map<unsigned int, Synchronisable*>::iterator it;
+    std::map<uint32_t, Synchronisable*>::iterator it;
     it = objectMap_.find(objectID);
     if (it != objectMap_.end())
@@ -199 +199 @@
    * @return true/false
    */
-  bool Synchronisable::deleteObject(unsigned int objectID){
+  bool Synchronisable::deleteObject(uint32_t objectID){
 //     assert(getSynchronisable(objectID));
     if(!getSynchronisable(objectID))
@@ -218 +218 @@
    * @return pointer to the Synchronisable with the objectID
    */
-  Synchronisable* Synchronisable::getSynchronisable(unsigned int objectID){
-    std::map<unsigned int, Synchronisable*>::iterator it1;
+  Synchronisable* Synchronisable::getSynchronisable(uint32_t objectID){
+    std::map<uint32_t, Synchronisable*>::iterator it1;
     it1 = objectMap_.find(objectID);
     if (it1 != objectMap_.end())
@@ -295 +295 @@
    * @return true: if !doSync or if everything was successfully saved
    */
-  bool Synchronisable::getData(uint8_t*& mem, unsigned int id, uint8_t mode){
+  bool Synchronisable::getData(uint8_t*& mem, int32_t id, uint8_t mode){
     if(mode==0x0)
       mode=state_;
@@ -302 +302 @@
       return true;
     //std::cout << "inside getData" << std::endl;
-    unsigned int tempsize = 0;
+    uint32_t tempsize = 0;
     if(classID==0)
       COUT(3) << "classid 0 " << this->getIdentifier()->getName() << std::endl;
 
-    if (this->classID == (unsigned int)-1)
+    if (this->classID == static_cast<uint32_t>(-1))
         this->classID = this->getIdentifier()->getNetworkID();
 
@@ -312 +312 @@
 //     this->classID=this->getIdentifier()->getNetworkID(); // TODO: correct this
     std::list<SynchronisableVariableBase*>::iterator i;
-    unsigned int size;
+    uint32_t size;
     size=getSize(id, mode);
 
@@ -384 +384 @@
   * @return amount of bytes
   */
-  uint32_t Synchronisable::getSize(unsigned int id, uint8_t mode){
+  uint32_t Synchronisable::getSize(int32_t id, uint8_t mode){
     int tsize=sizeof(synchronisableHeader);
     if(mode==0x0)
@@ -402 +402 @@
    * @return true/false
    */
-  bool Synchronisable::doSync(unsigned int id, uint8_t mode){
+  bool Synchronisable::doSync(int32_t id, uint8_t mode){
     if(mode==0x0)
       mode=state_;
@@ -408 +408 @@
   }
 
-  bool Synchronisable::doSelection(unsigned int id){
+  bool Synchronisable::doSelection(int32_t id){
     return true; //TODO: change this
     //return ( id==0 || id%objectFrequency_==objectID%objectFrequency_ ) && ((objectMode_&state_)!=0);

code/branches/network64/src/network/synchronisable/Synchronisable.h

@@ -53 +53 @@
 namespace orxonox
 {
-  static const unsigned int OBJECTID_UNKNOWN = (unsigned int)-1;
+  static const uint32_t OBJECTID_UNKNOWN = static_cast<uint32_t>(-1);
 
   namespace objectDirection{
@@ -86 +86 @@
 
     static Synchronisable *fabricate(uint8_t*& mem, uint8_t mode=0x0);
-    static bool deleteObject(unsigned int objectID);
-    static Synchronisable *getSynchronisable(unsigned int objectID);
+    static bool deleteObject(uint32_t objectID);
+    static Synchronisable *getSynchronisable(uint32_t objectID);
     static unsigned int getNumberOfDeletedObject(){ return deletedObjects_.size(); }
-    static unsigned int popDeletedObject(){ unsigned int i = deletedObjects_.front(); deletedObjects_.pop(); return i; }
+    static uint32_t popDeletedObject(){ uint32_t i = deletedObjects_.front(); deletedObjects_.pop(); return i; }
 
-    inline unsigned int getObjectID(){return objectID;}
-    inline unsigned int getClassID(){return classID;}
+    inline uint32_t getObjectID(){return objectID;}
+    inline uint32_t getClassID(){return classID;}
   protected:
     Synchronisable(BaseObject* creator);
@@ -103 +103 @@
 
   private:
-    bool getData(uint8_t*& men, unsigned int id, uint8_t mode=0x0);
-    uint32_t getSize(unsigned int id, uint8_t mode=0x0);
+    bool getData(uint8_t*& men, int32_t id, uint8_t mode=0x0);
+    uint32_t getSize(int32_t id, uint8_t mode=0x0);
     bool updateData(uint8_t*& mem, uint8_t mode=0x0, bool forceCallback=false);
     bool isMyData(uint8_t* mem);
-    bool doSelection(unsigned int id);
-    bool doSync(unsigned int id, uint8_t mode=0x0);
+    bool doSelection(int32_t id);
+    bool doSync(int32_t id, uint8_t mode=0x0);
 
-    unsigned int objectID;
-    unsigned int creatorID;
-    unsigned int classID;
+    uint32_t objectID;
+    uint32_t creatorID;
+    uint32_t classID;
 
     std::list<SynchronisableVariableBase*> syncList;
@@ -119 +119 @@
     unsigned int objectFrequency_;
     int objectMode_;
-    static std::map<unsigned int, Synchronisable *> objectMap_;
-    static std::queue<unsigned int> deletedObjects_;
+    static std::map<uint32_t, Synchronisable *> objectMap_;
+    static std::queue<uint32_t> deletedObjects_;
   };
   

code/branches/network64/src/network/synchronisable/SynchronisableSpecialisations.cc

@@ -37 +37 @@
   template <> void Synchronisable::registerVariable( const ColourValue& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)
   {
-    registerVariable(variable.r, mode, 0, bidirectional);
-    registerVariable(variable.g, mode, 0, bidirectional);
-    registerVariable(variable.b, mode, 0, bidirectional);
+    registerVariable(variable.r, mode, cb, bidirectional);
+    registerVariable(variable.g, mode, cb, bidirectional);
+    registerVariable(variable.b, mode, cb, bidirectional);
     registerVariable(variable.a, mode, cb, bidirectional);
   }
@@ -49 +49 @@
   template <> void Synchronisable::registerVariable( const Vector2& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)
   {
-    registerVariable(variable.x, mode, 0, bidirectional);
+    registerVariable(variable.x, mode, cb, bidirectional);
     registerVariable(variable.y, mode, cb, bidirectional);
   }
@@ -59 +59 @@
   template <> void Synchronisable::registerVariable( const Vector3& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)
   {
-    registerVariable(variable.x, mode, 0, bidirectional);
-    registerVariable(variable.y, mode, 0, bidirectional);
+    registerVariable(variable.x, mode, cb, bidirectional);
+    registerVariable(variable.y, mode, cb, bidirectional);
     registerVariable(variable.z, mode, cb, bidirectional);
   }
@@ -70 +70 @@
   template <> void Synchronisable::registerVariable( const Vector4& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)
   {
-    registerVariable(variable.x, mode, 0, bidirectional);
-    registerVariable(variable.y, mode, 0, bidirectional);
-    registerVariable(variable.z, mode, 0, bidirectional);
+    registerVariable(variable.x, mode, cb, bidirectional);
+    registerVariable(variable.y, mode, cb, bidirectional);
+    registerVariable(variable.z, mode, cb, bidirectional);
     registerVariable(variable.w, mode, cb, bidirectional);
   }
@@ -87 +87 @@
   template <> void Synchronisable::registerVariable( const Quaternion& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)
   {
-    registerVariable(variable.w, mode, 0, bidirectional);
-    registerVariable(variable.x, mode, 0, bidirectional);
-    registerVariable(variable.y, mode, 0, bidirectional);
+    registerVariable(variable.x, mode, cb, bidirectional);
+    registerVariable(variable.y, mode, cb, bidirectional);
     registerVariable(variable.z, mode, cb, bidirectional);
+    registerVariable(variable.w, mode, cb, bidirectional);
   }
   template <> void Synchronisable::registerVariable( Quaternion& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)

code/branches/network64/src/network/synchronisable/SynchronisableVariable.cc

@@ -64 +64 @@
 }
 
+// =========== char
+
+template <> uint32_t SynchronisableVariable<const char>::returnSize()
+{
+  return sizeof(uint8_t);
+}
+
+template <> void SynchronisableVariable<const char>::setAndIncrease( uint8_t*& mem )
+{
+  *(uint8_t*)(&this->variable_) = *static_cast<uint8_t*>(mem);
+  mem += SynchronisableVariable<const char>::returnSize();
+}
+
+template <> void SynchronisableVariable<const char>::getAndIncrease( uint8_t*& mem )
+{
+  *static_cast<uint8_t*>(mem) = *(uint8_t*)(&this->variable_);
+  mem += SynchronisableVariable<const char>::returnSize();
+}
+
+template <> bool SynchronisableVariable<const char>::checkEquality( uint8_t* mem )
+{
+  return *static_cast<uint8_t*>(mem) == *(uint8_t*)(&this->variable_);
+}
+
 // =========== unsigned char
 

code/branches/network64/src/network/synchronisable/SynchronisableVariable.h

@@ -39 +39 @@
 #include "core/CoreIncludes.h"
 #include "network/synchronisable/NetworkCallback.h"
+#include "network/synchronisable/NetworkCallbackManager.h"
 
 namespace orxonox{
@@ -119 +120 @@
   {
     if (this->callback_ != 0)
-      delete this->callback_;
+      NetworkCallbackManager::deleteCallback(this->callback_); //safe call for deletion
   }
 
@@ -146 +147 @@
   // now do a callback if neccessary
     if ( callback )
-      this->callback_->call();
+      NetworkCallbackManager::triggerCallback( this->callback_ );
+      //this->callback_->call();
   }
 
@@ -299 +301 @@
   // now do a callback if neccessary
       if ( callback )
-        this->callback_->call();
+        NetworkCallbackManager::triggerCallback( this->callback_ );
+        //this->callback_->call();
     }