Changeset 2794 for code/branches/netp/src/network/synchronisable

Timestamp:

Mar 17, 2009, 12:49:29 PM (16 years ago)

Author:

scheusso

Message:

some optimisations (mostly inlined SynchronisableVariable functions)
trying to track down a bug with enet connections

Location:

code/branches/netp/src/network/synchronisable

Files:

• SynchronisableVariable.cc (deleted)
• SynchronisableVariable.h (modified) (6 diffs)
• SynchronisableVariableSpecialisations.h (copied) (copied from code/trunk/src/network/synchronisable/SynchronisableVariable.cc) (50 diffs, 1 prop)

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

@@ -79 +79 @@
       virtual inline void* getReference(){ return (void *)&this->variable_; }
     protected:
-      bool checkEquality(uint8_t* mem);
-      void setAndIncrease(uint8_t*& mem);
-      void getAndIncrease(uint8_t*& mem);
-      uint32_t returnSize();
+      inline bool checkEquality(uint8_t* mem);
+      inline void setAndIncrease(uint8_t*& mem);
+      inline void getAndIncrease(uint8_t*& mem);
+      inline uint32_t returnSize();
       
       T& variable_;
@@ -97 +97 @@
       
       virtual inline uint8_t getMode(){ return 0x3; } //this basically is a hack ^^
-      virtual void getData(uint8_t*& mem, uint8_t mode);
+      virtual inline void getData(uint8_t*& mem, uint8_t mode);
       virtual void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false);
-      virtual uint32_t getSize(uint8_t mode);
+      virtual inline uint32_t getSize(uint8_t mode);
     private:
       T varBuffer_;
@@ -122 +122 @@
   }
 
-  template <class T> void SynchronisableVariable<T>::getData(uint8_t*& mem, uint8_t mode)
+  template <class T> inline void SynchronisableVariable<T>::getData(uint8_t*& mem, uint8_t mode)
   {
     if ( state_ == this->mode_ )
@@ -143 +143 @@
   // write the data
     setAndIncrease( mem );
-//   mem += SynchronisableVariable<T>::getSize();
   // now do a callback if neccessary
     if ( callback )
       NetworkCallbackManager::triggerCallback( this->callback_ );
-      //this->callback_->call();
-  }
-
-  template <class T> uint32_t SynchronisableVariable<T>::getSize(uint8_t mode)
+  }
+
+  template <class T> inline uint32_t SynchronisableVariable<T>::getSize(uint8_t mode)
   {
     if ( mode == this->mode_ )
@@ -304 +302 @@
     }
 
-    template <class T> uint32_t SynchronisableVariableBidirectional<T>::getSize(uint8_t mode)
+    template <class T> inline uint32_t SynchronisableVariableBidirectional<T>::getSize(uint8_t mode)
     {
       return SynchronisableVariable<T>::returnSize() + sizeof(varReference_);
@@ -312 +310 @@
 }
 
+#include "network/synchronisable/SynchronisableVariableSpecialisations.h"
 
 #endif

code/branches/netp/src/network/synchronisable/SynchronisableVariableSpecialisations.h

@@ -27 +27 @@
  */
 
-#include "SynchronisableVariable.h"
 #include <cstring>
 #include "util/Math.h"
 
+#ifndef _NETWORK_SYNCHRONISABLEVARIABLESPECIALISATIONS__
+#define _NETWORK_SYNCHRONISABLEVARIABLESPECIALISATIONS__
 
 namespace orxonox{
 
-uint8_t SynchronisableVariableBase::state_ = 0;
-
 
 
@@ -42 +41 @@
 // =========== bool
 
-template <> uint32_t SynchronisableVariable<const bool>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const bool>::returnSize()
 {
   return sizeof(uint8_t);
 }
 
-template <> void SynchronisableVariable<const bool>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const bool>::setAndIncrease( uint8_t*& mem )
 {
   *(uint8_t*)(&this->variable_) = *static_cast<uint8_t*>(mem);
@@ -53 +52 @@
 }
 
-template <> void SynchronisableVariable<const bool>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const bool>::getAndIncrease( uint8_t*& mem )
 {
   *static_cast<uint8_t*>(mem) = *(uint8_t*)(&this->variable_);
@@ -59 +58 @@
 }
 
-template <> bool SynchronisableVariable<const bool>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const bool>::checkEquality( uint8_t* mem )
 {
   return *static_cast<uint8_t*>(mem) == *(uint8_t*)(&this->variable_);
@@ -66 +65 @@
 // =========== char
 
-template <> uint32_t SynchronisableVariable<const char>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const char>::returnSize()
 {
   return sizeof(uint8_t);
 }
 
-template <> void SynchronisableVariable<const char>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const char>::setAndIncrease( uint8_t*& mem )
 {
   *(uint8_t*)(&this->variable_) = *static_cast<uint8_t*>(mem);
@@ -77 +76 @@
 }
 
-template <> void SynchronisableVariable<const char>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const char>::getAndIncrease( uint8_t*& mem )
 {
   *static_cast<uint8_t*>(mem) = *(uint8_t*)(&this->variable_);
@@ -83 +82 @@
 }
 
-template <> bool SynchronisableVariable<const char>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const char>::checkEquality( uint8_t* mem )
 {
   return *static_cast<uint8_t*>(mem) == *(uint8_t*)(&this->variable_);
@@ -90 +89 @@
 // =========== unsigned char
 
-template <> uint32_t SynchronisableVariable<const unsigned char>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const unsigned char>::returnSize()
 {
   return sizeof(uint8_t);
 }
 
-template <> void SynchronisableVariable<const unsigned char>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const unsigned char>::setAndIncrease( uint8_t*& mem )
 {
   *(uint8_t*)(&this->variable_) = *static_cast<uint8_t*>(mem);
@@ -101 +100 @@
 }
 
-template <> void SynchronisableVariable<const unsigned char>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const unsigned char>::getAndIncrease( uint8_t*& mem )
 {
   *static_cast<uint8_t*>(mem) = *(uint8_t*)(&this->variable_);
@@ -107 +106 @@
 }
 
-template <> bool SynchronisableVariable<const unsigned char>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const unsigned char>::checkEquality( uint8_t* mem )
 {
   return *static_cast<uint8_t*>(mem) == *(uint8_t*)(&this->variable_);
@@ -114 +113 @@
 // =========== short
 
-template <> uint32_t SynchronisableVariable<const short>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const short>::returnSize()
 {
   return sizeof(int16_t);
 }
 
-template <> void SynchronisableVariable<const short>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const short>::setAndIncrease( uint8_t*& mem )
 {
   *(short*)(&this->variable_) = *(int16_t*)(mem);
@@ -125 +124 @@
 }
 
-template <> void SynchronisableVariable<const short>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const short>::getAndIncrease( uint8_t*& mem )
 {
   *(int16_t*)(mem) = this->variable_;
@@ -131 +130 @@
 }
 
-template <> bool SynchronisableVariable<const short>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const short>::checkEquality( uint8_t* mem )
 {
   return *(int16_t*)(mem) == static_cast<int16_t>(this->variable_);
@@ -138 +137 @@
 // =========== unsigned short
 
-template <> uint32_t SynchronisableVariable<const unsigned short>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const unsigned short>::returnSize()
 {
   return sizeof(uint16_t);
 }
 
-template <> void SynchronisableVariable<const unsigned short>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const unsigned short>::setAndIncrease( uint8_t*& mem )
 {
   *(unsigned short*)(&this->variable_) = *(uint16_t*)(mem);
@@ -149 +148 @@
 }
 
-template <> void SynchronisableVariable<const unsigned short>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const unsigned short>::getAndIncrease( uint8_t*& mem )
 {
   *(uint16_t*)(mem) = this->variable_;
@@ -155 +154 @@
 }
 
-template <> bool SynchronisableVariable<const unsigned short>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const unsigned short>::checkEquality( uint8_t* mem )
 {
   return *(uint16_t*)(mem) == this->variable_;
@@ -162 +161 @@
 // =========== int
 
-template <> uint32_t SynchronisableVariable<const int>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const int>::returnSize()
 {
   return sizeof(int32_t);
 }
 
-template <> void SynchronisableVariable<const int>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const int>::setAndIncrease( uint8_t*& mem )
 {
   *(int *)(&this->variable_) = *(int32_t*)(mem);
@@ -173 +172 @@
 }
 
-template <> void SynchronisableVariable<const int>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const int>::getAndIncrease( uint8_t*& mem )
 {
   *(int32_t*)(mem) = this->variable_;
@@ -179 +178 @@
 }
 
-template <> bool SynchronisableVariable<const int>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const int>::checkEquality( uint8_t* mem )
 {
   return *(int32_t*)(mem) == this->variable_;
@@ -186 +185 @@
 // =========== unsigned int
 
-template <> uint32_t SynchronisableVariable<const unsigned int>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const unsigned int>::returnSize()
 {
   return sizeof(uint32_t);
 }
     
-template <> void SynchronisableVariable<const unsigned int>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const unsigned int>::setAndIncrease( uint8_t*& mem )
 {
   *(unsigned int*)(&this->variable_) = *(uint32_t*)(mem);
@@ -197 +196 @@
 }
 
-template <> void SynchronisableVariable<const unsigned int>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const unsigned int>::getAndIncrease( uint8_t*& mem )
 {
   *(uint32_t*)(mem) = this->variable_;
@@ -203 +202 @@
 }
 
-template <> bool SynchronisableVariable<const unsigned int>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const unsigned int>::checkEquality( uint8_t* mem )
 {
   return *(uint32_t*)(mem) == this->variable_;
@@ -210 +209 @@
 // =========== long
 
-template <> uint32_t SynchronisableVariable<const long>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const long>::returnSize()
 {
   return sizeof(int32_t);
 }
 
-template <> void SynchronisableVariable<const long>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const long>::setAndIncrease( uint8_t*& mem )
 {
   *(long*)(&this->variable_) = *(int32_t*)(mem);
@@ -221 +220 @@
 }
 
-template <> void SynchronisableVariable<const long>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const long>::getAndIncrease( uint8_t*& mem )
 {
   *(int32_t*)(mem) = this->variable_;
@@ -227 +226 @@
 }
 
-template <> bool SynchronisableVariable<const long>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const long>::checkEquality( uint8_t* mem )
 {
   return *(int32_t*)(mem) == this->variable_;
@@ -234 +233 @@
 // =========== unsigned long
 
-template <> uint32_t SynchronisableVariable<const unsigned long>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const unsigned long>::returnSize()
 {
   return sizeof(uint32_t);
 }
 
-template <> void SynchronisableVariable<const unsigned long>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const unsigned long>::setAndIncrease( uint8_t*& mem )
 {
   *(unsigned long*)(&this->variable_) = *(uint32_t*)(mem);
@@ -245 +244 @@
 }
 
-template <> void SynchronisableVariable<const unsigned long>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const unsigned long>::getAndIncrease( uint8_t*& mem )
 {
   *(uint32_t*)(mem) = this->variable_;
@@ -251 +250 @@
 }
 
-template <> bool SynchronisableVariable<const unsigned long>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const unsigned long>::checkEquality( uint8_t* mem )
 {
   return *(uint32_t*)(mem) == this->variable_;
@@ -258 +257 @@
 // =========== long long
 
-template <> uint32_t SynchronisableVariable<const long long>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const long long>::returnSize()
 {
   return sizeof(int64_t);
 }
 
-template <> void SynchronisableVariable<const long long>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const long long>::setAndIncrease( uint8_t*& mem )
 {
   *(long long*)(&this->variable_) = *(int64_t*)(mem);
@@ -269 +268 @@
 }
 
-template <> void SynchronisableVariable<const long long>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const long long>::getAndIncrease( uint8_t*& mem )
 {
   *(int64_t*)(mem) = this->variable_;
@@ -275 +274 @@
 }
 
-template <> bool SynchronisableVariable<const long long>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const long long>::checkEquality( uint8_t* mem )
 {
   return *(int64_t*)(mem) == this->variable_;
@@ -282 +281 @@
 // =========== unsigned long long
 
-template <> uint32_t SynchronisableVariable<const unsigned long long>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const unsigned long long>::returnSize()
 {
   return sizeof(uint64_t);
 }
 
-template <> void SynchronisableVariable<const unsigned long long>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const unsigned long long>::setAndIncrease( uint8_t*& mem )
 {
   *(unsigned long long*)(&this->variable_) = *(uint64_t*)(mem);
@@ -293 +292 @@
 }
 
-template <> void SynchronisableVariable<const unsigned long long>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const unsigned long long>::getAndIncrease( uint8_t*& mem )
 {
   *(uint64_t*)(mem) = this->variable_;
@@ -299 +298 @@
 }
 
-template <> bool SynchronisableVariable<const unsigned long long>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const unsigned long long>::checkEquality( uint8_t* mem )
 {
   return *(uint64_t*)(mem) == this->variable_;
@@ -306 +305 @@
 // =========== float
 
-template <> uint32_t SynchronisableVariable<const float>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const float>::returnSize()
 {
   return sizeof(uint32_t);
 }
 
-template <> void SynchronisableVariable<const float>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const float>::setAndIncrease( uint8_t*& mem )
 {
   *(uint32_t*)(&this->variable_) = *(uint32_t*)(mem);
@@ -317 +316 @@
 }
 
-template <> void SynchronisableVariable<const float>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const float>::getAndIncrease( uint8_t*& mem )
 {
   *(uint32_t*)(mem) = *(uint32_t*)(&this->variable_);
@@ -323 +322 @@
 }
 
-template <> bool SynchronisableVariable<const float>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const float>::checkEquality( uint8_t* mem )
 {
   return *(uint32_t*)(mem) == *(uint32_t*)(&this->variable_);
@@ -330 +329 @@
 // =========== double
 
-template <> uint32_t SynchronisableVariable<const double>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const double>::returnSize()
 {
   return sizeof(uint64_t);
 }
 
-template <> void SynchronisableVariable<const double>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const double>::setAndIncrease( uint8_t*& mem )
 {
   *(uint64_t*)(&this->variable_) = *(uint64_t*)(mem);
@@ -341 +340 @@
 }
 
-template <> void SynchronisableVariable<const double>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const double>::getAndIncrease( uint8_t*& mem )
 {
   *(uint64_t*)(mem) = *(uint64_t*)(&this->variable_);
@@ -347 +346 @@
 }
 
-template <> bool SynchronisableVariable<const double>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const double>::checkEquality( uint8_t* mem )
 {
   return *(uint64_t*)(mem) == *(uint64_t*)(&this->variable_);
@@ -354 +353 @@
 // =========== long double
 
-template <> uint32_t SynchronisableVariable<const long double>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const long double>::returnSize()
 {
   return sizeof(uint64_t);
 }
 
-template <> void SynchronisableVariable<const long double>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const long double>::setAndIncrease( uint8_t*& mem )
 {
   double temp;
@@ -367 +366 @@
 }
 
-template <> void SynchronisableVariable<const long double>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const long double>::getAndIncrease( uint8_t*& mem )
 {
   double temp = static_cast<double>(this->variable_);
@@ -374 +373 @@
 }
 
-template <> bool SynchronisableVariable<const long double>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const long double>::checkEquality( uint8_t* mem )
 {
   double temp = static_cast<double>(this->variable_);
@@ -382 +381 @@
 // =========== string
 
-template <> uint32_t SynchronisableVariable<const std::string>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const std::string>::returnSize()
 {
   return variable_.length()+1;
 }
 
-template <> void SynchronisableVariable<const std::string>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const std::string>::getAndIncrease( uint8_t*& mem )
 {
   memcpy(mem, this->variable_.c_str(), this->variable_.length()+1);
@@ -393 +392 @@
 }
 
-template <> void SynchronisableVariable<const std::string>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const std::string>::setAndIncrease( uint8_t*& mem )
 {
   *(std::string*)(&this->variable_) = std::string((const char *)mem);
@@ -399 +398 @@
 }
 
-template <> bool SynchronisableVariable<const std::string>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const std::string>::checkEquality( uint8_t* mem )
 {
   return std::string((const char*)mem)==this->variable_;
@@ -406 +405 @@
 // =========== Degree
 
-template <> uint32_t SynchronisableVariable<const Degree>::returnSize()
+template <> inline uint32_t SynchronisableVariable<const Degree>::returnSize()
 {
   return sizeof(Ogre::Real);
 }
 
-template <> void SynchronisableVariable<const Degree>::getAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const Degree>::getAndIncrease( uint8_t*& mem )
 {
   Ogre::Real r = this->variable_.valueDegrees();
@@ -418 +417 @@
 }
 
-template <> void SynchronisableVariable<const Degree>::setAndIncrease( uint8_t*& mem )
+template <> inline void SynchronisableVariable<const Degree>::setAndIncrease( uint8_t*& mem )
 {
   Ogre::Real* r = (Ogre::Real*)mem;
@@ -425 +424 @@
 }
 
-template <> bool SynchronisableVariable<const Degree>::checkEquality( uint8_t* mem )
+template <> inline bool SynchronisableVariable<const Degree>::checkEquality( uint8_t* mem )
 {
   Ogre::Real* r = (Ogre::Real*)mem;
@@ -432 +431 @@
 
 }
+
+
+#endif