Changeset 6123 for code

Timestamp:

Nov 23, 2009, 8:19:58 PM (15 years ago)

Author:

scheusso

Message:

synchronisation of pointers to classes that inherit from Synchronisable are now possible
just use the normal registerVariable syntax

Location:

code/branches/presentation2/src

Files:

• libraries/network/synchronisable/CMakeLists.txt (modified) (1 diff)
• libraries/network/synchronisable/Synchronisable.h (modified) (2 diffs)
• libraries/network/synchronisable/SynchronisableVariable.h (modified) (2 diffs)
• libraries/util/Serialise.h (modified) (2 diffs)
• orxonox/Test.cc (modified) (3 diffs)
• orxonox/Test.h (modified) (2 diffs)

code/branches/presentation2/src/libraries/network/synchronisable/CMakeLists.txt

@@ -10 +10 @@
   NetworkCallbackManager.h
   Synchronisable.h
+  SynchronisablePointer.h
   SynchronisableVariable.h
 )

code/branches/presentation2/src/libraries/network/synchronisable/Synchronisable.h

@@ -138 +138 @@
     Synchronisable(BaseObject* creator);
     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 setPriority(unsigned int freq){ objectFrequency_ = freq; }
 
@@ -187 +186 @@
     if (bidirectional)
     {
-      syncList.push_back(new SynchronisableVariableBidirectional<const T>(variable, mode, cb));
+      syncList.push_back(new SynchronisableVariableBidirectional<T>(variable, mode, cb));
       this->dataSize_ += syncList.back()->getSize(state_);
     }
     else
     {
-      syncList.push_back(new SynchronisableVariable<const T>(variable, mode, cb));
+      syncList.push_back(new SynchronisableVariable<T>(variable, mode, cb));
       if ( this->state_ == mode )
         this->dataSize_ += syncList.back()->getSize(state_);
     }
   }
-  
-
-
-//   template <class T> void Synchronisable::unregisterVariable(T& var){
-//     std::vector<SynchronisableVariableBase*>::iterator it = syncList.begin();
-//     while(it!=syncList.end()){
-//       if( ((*it)->getReference()) == &var ){
-//         delete (*it);
-//         syncList.erase(it);
-//         return;
-//       }
-//       else
-//         it++;
-//     }
-//     bool unregistered_nonexistent_variable = false;
-//     assert(unregistered_nonexistent_variable); //if we reach this point something went wrong:
-//     // the variable has not been registered before
-//   }
 
   

code/branches/presentation2/src/libraries/network/synchronisable/SynchronisableVariable.h

@@ -35 +35 @@
 #include <cassert>
 #include <cstring>
-#include "util/Serialise.h"
+#include "Serialise.h"
 #include "util/TypeTraits.h"
 #include "core/GameMode.h"
@@ -143 +143 @@
     if ( this->callback_ != 0 )
     {
-      if( forceCallback || !checkEquality( this->variable_, mem ) )
-        callback = true;
+      callback = forceCallback || !checkEquality( this->variable_, mem );
     }
   // write the data

code/branches/presentation2/src/libraries/util/Serialise.h

@@ -40 +40 @@
 namespace orxonox{
     
-// general template declaration
-    
     /** @brief returns the size of the variable in a datastream */
-    template <class T> inline uint32_t returnSize( const T& );
+    template <class T> inline uint32_t returnSize( const T& variable );
     /** @brief loads the value of a variable out of the bytestream and increases the mem pointer */
-    template <class T> inline void loadAndIncrease( const T&, uint8_t*& );
+    template <class T> inline void loadAndIncrease( const T& variable, uint8_t*& mem );
     /** @brief saves the value of a variable into the bytestream and increases the mem pointer */
-    template <class T> inline void saveAndIncrease( const T&, uint8_t*& );
+    template <class T> inline void saveAndIncrease( const T& variable, uint8_t*& mem );
     /** @brief checks whether the variable of type T is the same as in the bytestream */
-    template <class T> inline  bool checkEquality( const T&, uint8_t* );
+    template <class T> inline bool checkEquality( const T& variable, uint8_t* mem );
 
 // =================== Template specialisation stuff =============
@@ -471 +469 @@
         return variable==Degree(*r);
     }
-    
-    
 }
 

code/branches/presentation2/src/orxonox/Test.cc

@@ -38 +38 @@
     CreateFactory ( Test );
   
-  SetConsoleCommand(Test, printV1, true).accessLevel(AccessLevel::User);
-  SetConsoleCommand(Test, printV2, true).accessLevel(AccessLevel::User);
-  SetConsoleCommand(Test, printV3, true).accessLevel(AccessLevel::User);
-  SetConsoleCommand(Test, printV4, true).accessLevel(AccessLevel::User);
-  SetConsoleCommand(Test, call, true).accessLevel(AccessLevel::User);
-  SetConsoleCommand(Test, call2, true).accessLevel(AccessLevel::User);
+    SetConsoleCommand(Test, printV1, true).accessLevel(AccessLevel::User);
+    SetConsoleCommand(Test, printV2, true).accessLevel(AccessLevel::User);
+    SetConsoleCommand(Test, printV3, true).accessLevel(AccessLevel::User);
+    SetConsoleCommand(Test, printV4, true).accessLevel(AccessLevel::User);
+    SetConsoleCommand(Test, call, true).accessLevel(AccessLevel::User);
+    SetConsoleCommand(Test, call2, true).accessLevel(AccessLevel::User);
   
   
@@ -50 +50 @@
 //   NetworkFunctionBase* NETWORK_FUNCTION_TEST_C = new NetworkFunctionStatic( createFunctor(&Test::printV1), "bla", NETWORK_FUNCTION_POINTER );
   
-  registerStaticNetworkFunction( &Test::printV1 );
-  registerMemberNetworkFunction( Test, checkU1 );
-  registerMemberNetworkFunction( Test, printBlaBla );
+    registerStaticNetworkFunction( &Test::printV1 );
+    registerMemberNetworkFunction( Test, checkU1 );
+    registerMemberNetworkFunction( Test, printBlaBla );
   
-  Test* Test::instance_ = 0;
+    Test* Test::instance_ = 0;
 
     Test::Test(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
     {
-    assert(instance_==0);
-    instance_=this;
+        assert(instance_==0);
+        instance_=this;
         RegisterObject ( Test );
-    setConfigValues();
-    registerVariables();
+        setConfigValues();
+        registerVariables();
         setSyncMode(0x3);
+        this->pointer_ = 0;
     }
 
     Test::~Test()
     {
-    instance_=0;
+        instance_=0;
     }
 
@@ -74 +75 @@
     {
         SetConfigValue ( u1, 1 )/*.callback ( this, &Test::checkV1 )*/;
-    SetConfigValue ( u2, 2 )/*.callback ( this, &Test::checkV2 )*/;
-    SetConfigValue ( u3, 3 )/*.callback ( this, &Test::checkV3 )*/;
-    SetConfigValue ( u4, 4 )/*.callback ( this, &Test::checkV4 )*/;
+        SetConfigValue ( u2, 2 )/*.callback ( this, &Test::checkV2 )*/;
+        SetConfigValue ( u3, 3 )/*.callback ( this, &Test::checkV3 )*/;
+        SetConfigValue ( u4, 4 )/*.callback ( this, &Test::checkV4 )*/;
     
-    SetConfigValue ( s1, 1 )/*.callback ( this, &Test::checkV1 )*/;
-    SetConfigValue ( s2, 2 )/*.callback ( this, &Test::checkV2 )*/;
-    SetConfigValue ( s3, 3 )/*.callback ( this, &Test::checkV3 )*/;
-    SetConfigValue ( s4, 4 )/*.callback ( this, &Test::checkV4 )*/;
+        SetConfigValue ( s1, 1 )/*.callback ( this, &Test::checkV1 )*/;
+        SetConfigValue ( s2, 2 )/*.callback ( this, &Test::checkV2 )*/;
+        SetConfigValue ( s3, 3 )/*.callback ( this, &Test::checkV3 )*/;
+        SetConfigValue ( s4, 4 )/*.callback ( this, &Test::checkV4 )*/;
     }
 
 
-  void Test::registerVariables()
-  {
-    registerVariable ( u1, variableDirection::toclient, new NetworkCallback<Test> ( this, &Test::checkU1 ));
-    registerVariable ( u2, variableDirection::toserver, new NetworkCallback<Test> ( this, &Test::checkU2 ));
-    registerVariable ( u3, variableDirection::serverMaster, new NetworkCallback<Test> ( this, &Test::checkU3 ), true );
-    registerVariable ( u4, variableDirection::clientMaster, new NetworkCallback<Test> ( this, &Test::checkU4 ), true );
+    void Test::registerVariables()
+    {
+        registerVariable ( u1, VariableDirection::ToClient, new NetworkCallback<Test> ( this, &Test::checkU1 ));
+        registerVariable ( u2, VariableDirection::ToServer, new NetworkCallback<Test> ( this, &Test::checkU2 ));
+        registerVariable ( u3, Bidirectionality::ServerMaster, new NetworkCallback<Test> ( this, &Test::checkU3 ), true );
+        registerVariable ( u4, Bidirectionality::ClientMaster, new NetworkCallback<Test> ( this, &Test::checkU4 ), true );
     
-    registerVariable ( s1, variableDirection::toclient, new NetworkCallback<Test> ( this, &Test::checkS1 ));
-    registerVariable ( s2, variableDirection::toserver, new NetworkCallback<Test> ( this, &Test::checkS2 ));
-    registerVariable ( s3, variableDirection::serverMaster, new NetworkCallback<Test> ( this, &Test::checkS3 ), true );
-    registerVariable ( s4, variableDirection::clientMaster, new NetworkCallback<Test> ( this, &Test::checkS4 ), true );
-  }
+        registerVariable ( s1, VariableDirection::ToClient, new NetworkCallback<Test> ( this, &Test::checkS1 ));
+        registerVariable ( s2, VariableDirection::ToServer, new NetworkCallback<Test> ( this, &Test::checkS2 ));
+        registerVariable ( s3, Bidirectionality::ServerMaster, new NetworkCallback<Test> ( this, &Test::checkS3 ), true );
+        registerVariable ( s4, Bidirectionality::ClientMaster, new NetworkCallback<Test> ( this, &Test::checkS4 ), true );
+    
+        registerVariable ( pointer_, VariableDirection::ToClient, new NetworkCallback<Test> ( this, &Test::printPointer ) );
+    }
   
   void Test::call(unsigned int clientID)
-  {
-    callStaticNetworkFunction( &Test::printV1, clientID );
-    callStaticNetworkFunction( &Test::printV1, clientID );
-  }
+    {
+        callStaticNetworkFunction( &Test::printV1, clientID );
+        callStaticNetworkFunction( &Test::printV1, clientID );
+    }
   
-  void Test::call2(unsigned int clientID, std::string s1, std::string s2, std::string s3, std::string s4)
-  {
-    callMemberNetworkFunction( Test, printBlaBla, this->getObjectID(), clientID, s1, s2, s3, s4, s4 );
-  }
+    void Test::call2(unsigned int clientID, std::string s1, std::string s2, std::string s3, std::string s4)
+    {
+        callMemberNetworkFunction( Test, printBlaBla, this->getObjectID(), clientID, s1, s2, s3, s4, s4 );
+    }
   
-  void Test::tick(float dt)
-  {
-//     std::string str1 = "blub";
-//     //MultiType mt1(std::string("blub"));
-//     MultiType mt1(str1);
-//     uint8_t* mem = new uint8_t[mt1.getNetworkSize()];
-//     uint8_t* temp = mem;
-//     mt1.exportData( temp );
-//     assert( temp-mem == mt1.getNetworkSize() );
-//     MultiType mt2;
-//     temp = mem;
-//     mt2.importData( temp );
-//     assert( temp-mem == mt1.getNetworkSize() );
-//     COUT(0) << mt2 << endl;
-    if(!Core::isMaster())
-      call2(0, "bal", "a", "n", "ce");
-//       callMemberNetworkFunction( Test, checkU1, this->getObjectID(), 0 );
-  }
-  
-  void Test::printBlaBla(std::string s1, std::string s2, std::string s3, std::string s4, std::string s5)
-  {
-    COUT(0) << s1 << s2 << s3 << s4 << s5 << endl;
-  }
-  
-  void Test::checkU1(){ COUT(1) << "U1 changed: " << u1 << std::endl; }
-  void Test::checkU2(){ COUT(1) << "U2 changed: " << u2 << std::endl; }
-  void Test::checkU3(){ COUT(1) << "U3 changed: " << u3 << std::endl; }
-  void Test::checkU4(){ COUT(1) << "U4 changed: " << u4 << std::endl; }
+    void Test::tick(float dt)
+    {
+    //     std::string str1 = "blub";
+    //     //MultiType mt1(std::string("blub"));
+    //     MultiType mt1(str1);
+    //     uint8_t* mem = new uint8_t[mt1.getNetworkSize()];
+    //     uint8_t* temp = mem;
+    //     mt1.exportData( temp );
+    //     assert( temp-mem == mt1.getNetworkSize() );
+    //     MultiType mt2;
+    //     temp = mem;
+    //     mt2.importData( temp );
+    //     assert( temp-mem == mt1.getNetworkSize() );
+    //     COUT(0) << mt2 << endl;
+    //     if(!Core::isMaster())
+    //       call2(0, "bal", "a", "n", "ce");
+    //       callMemberNetworkFunction( Test, checkU1, this->getObjectID(), 0 );
+    }
+    
+    void Test::printBlaBla(std::string s1, std::string s2, std::string s3, std::string s4, std::string s5)
+    {
+        COUT(0) << s1 << s2 << s3 << s4 << s5 << endl;
+    }
+    
+    void Test::checkU1(){ COUT(1) << "U1 changed: " << u1 << std::endl; }
+    void Test::checkU2(){ COUT(1) << "U2 changed: " << u2 << std::endl; }
+    void Test::checkU3(){ COUT(1) << "U3 changed: " << u3 << std::endl; }
+    void Test::checkU4(){ COUT(1) << "U4 changed: " << u4 << std::endl; }
 
-  void Test::checkS1(){ COUT(1) << "S1 changed: " << s1 << std::endl; }
-  void Test::checkS2(){ COUT(1) << "S2 changed: " << s2 << std::endl; }
-  void Test::checkS3(){ COUT(1) << "S3 changed: " << s3 << std::endl; }
-  void Test::checkS4(){ COUT(1) << "S4 changed: " << s4 << std::endl; }
+    void Test::checkS1(){ COUT(1) << "S1 changed: " << s1 << std::endl; }
+    void Test::checkS2(){ COUT(1) << "S2 changed: " << s2 << std::endl; }
+    void Test::checkS3(){ COUT(1) << "S3 changed: " << s3 << std::endl; }
+    void Test::checkS4(){ COUT(1) << "S4 changed: " << s4 << std::endl; }
+    
+    void Test::printPointer(){ CCOUT(1) << "pointer: " << this->pointer_ << endl; }
 
 }

code/branches/presentation2/src/orxonox/Test.h

@@ -75 +75 @@
       void checkS3();
       void checkS4();
+      
+      void printPointer();
 
       static void printV1(){ instance_->checkU1(); }
@@ -93 +95 @@
       TYPE s3;
       TYPE s4;
+      
+      Test* pointer_;
 
       static Test* instance_;