Changeset 7495 for code/trunk/src/libraries

Timestamp:

Sep 28, 2010, 9:48:32 PM (14 years ago)

Author:

scheusso

Message:

buffering incoming function calls for non-existing objects works now

Location:

code/trunk/src/libraries/network

Files:

• Client.cc (modified) (1 diff)
• FunctionCall.cc (modified) (1 diff)
• FunctionCall.h (modified) (1 diff)
• FunctionCallManager.cc (modified) (4 diffs)
• FunctionCallManager.h (modified) (2 diffs)
• NetworkFunction.h (modified) (2 diffs)
• packet/FunctionCalls.cc (modified) (2 diffs)

code/trunk/src/libraries/network/Client.cc

@@ -175 +175 @@
     if(gamestate->processGamestates())
     {
+      FunctionCallManager::processBufferedFunctionCalls();
       if(!isSynched_)
         isSynched_=true;

code/trunk/src/libraries/network/FunctionCall.cc

@@ -80 +80 @@
     {
       case 0:
-        fct->call(this->objectID_);
+        if( !fct->call(this->objectID_) )
+          return false;
         break;
       case 1:
-        fct->call(this->objectID_, this->arguments_[0]);
+        if( !fct->call(this->objectID_, this->arguments_[0]) )
+          return false;
         break;
       case 2:
-        fct->call(this->objectID_, this->arguments_[0], this->arguments_[1]);
+        if( !fct->call(this->objectID_, this->arguments_[0], this->arguments_[1]) )
+          return false;
         break;
       case 3:
-        fct->call(this->objectID_, this->arguments_[0], this->arguments_[1], this->arguments_[2]);
+        if( !fct->call(this->objectID_, this->arguments_[0], this->arguments_[1], this->arguments_[2]) )
+          return false;
         break;
       case 4:
-        fct->call(this->objectID_, this->arguments_[0], this->arguments_[1], this->arguments_[2], this->arguments_[3]);
+        if( !fct->call(this->objectID_, this->arguments_[0], this->arguments_[1], this->arguments_[2], this->arguments_[3]) )
+          return false;
         break;
       case 5:
-        fct->call(this->objectID_, this->arguments_[0], this->arguments_[1], this->arguments_[2], this->arguments_[3], this->arguments_[4]);
+        if( !fct->call(this->objectID_, this->arguments_[0], this->arguments_[1], this->arguments_[2], this->arguments_[3], this->arguments_[4]) )
+          return false;
         break;
       default:

code/trunk/src/libraries/network/FunctionCall.h

@@ -32 +32 @@
 #include "network/NetworkPrereqs.h"
 #include "util/UtilPrereqs.h"
+#include "util/MultiType.h"
 
 #include <cassert>

code/trunk/src/libraries/network/FunctionCallManager.cc

@@ -29 +29 @@
 #include "FunctionCallManager.h"
 #include "packet/FunctionCalls.h"
+#include "core/GameMode.h"
 
 namespace orxonox {
 
-std::map<uint32_t, packet::FunctionCalls*> FunctionCallManager::clientMap_;
+std::map<uint32_t, packet::FunctionCalls*> FunctionCallManager::sClientMap_;
+std::vector<FunctionCall> FunctionCallManager::sIncomingFunctionCallBuffer_;
 
 // Static calls
@@ -38 +40 @@
 void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t clientID)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager::clientMap_[clientID]->addCallStatic(functionID);
+  FunctionCallManager::sClientMap_[clientID]->addCallStatic(functionID);
 }
 void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager:: clientMap_[clientID]->addCallStatic(functionID, &mt1);
+  FunctionCallManager:: sClientMap_[clientID]->addCallStatic(functionID, &mt1);
 }
 void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager:: clientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2);
+  FunctionCallManager:: sClientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2);
 }
 void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager:: clientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2, &mt3);
+  FunctionCallManager:: sClientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2, &mt3);
 }
 void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager:: clientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2, &mt3, &mt4);
+  FunctionCallManager:: sClientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2, &mt3, &mt4);
 }
 void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager:: clientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2, &mt3, &mt4, &mt5);
+  FunctionCallManager:: sClientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2, &mt3, &mt4, &mt5);
 }
 
@@ -96 +98 @@
 void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager::clientMap_[clientID]->addCallMember(functionID, objectID);
+  FunctionCallManager::sClientMap_[clientID]->addCallMember(functionID, objectID);
 }
 void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager::clientMap_[clientID]->addCallMember(functionID, objectID, &mt1);
+  FunctionCallManager::sClientMap_[clientID]->addCallMember(functionID, objectID, &mt1);
 }
 void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager::clientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2);
+  FunctionCallManager::sClientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2);
 }
 void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager::clientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3);
+  FunctionCallManager::sClientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3);
 }
 void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager::clientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3, &mt4);
+  FunctionCallManager::sClientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3, &mt4);
 }
 void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager::clientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3, &mt4, &mt5);
+  FunctionCallManager::sClientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3, &mt4, &mt5);
 }
 
@@ -154 +156 @@
 {
   std::map<uint32_t, packet::FunctionCalls*>::iterator it;
-  for (it = FunctionCallManager::clientMap_.begin(); it != FunctionCallManager::clientMap_.end(); it++ )
+  for (it = FunctionCallManager::sClientMap_.begin(); it != FunctionCallManager::sClientMap_.end(); ++it )
   {
-    assert(!FunctionCallManager::clientMap_.empty());
+    assert(!FunctionCallManager::sClientMap_.empty());
     it->second->send();
   }
-  FunctionCallManager::clientMap_.clear();
+  FunctionCallManager::sClientMap_.clear();
+}
+
+void FunctionCallManager::bufferIncomingFunctionCall(const orxonox::FunctionCall& fctCall)
+{
+  if( !GameMode::isMaster() )
+    FunctionCallManager::sIncomingFunctionCallBuffer_.push_back( fctCall );
+}
+
+void FunctionCallManager::processBufferedFunctionCalls()
+{
+  std::vector<FunctionCall>::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
+  while( it!=FunctionCallManager::sIncomingFunctionCallBuffer_.end() )
+  {
+    if( it->execute() )
+      FunctionCallManager::sIncomingFunctionCallBuffer_.erase(it);
+    else
+      ++it;
+  }
 }
 

code/trunk/src/libraries/network/FunctionCallManager.h

@@ -33 +33 @@
 
 #include <map>
+#include <vector>
 #include "util/UtilPrereqs.h"
+#include "FunctionCall.h"
 
 namespace orxonox {
@@ -58 +60 @@
 
   static void sendCalls();
+  
+  static void bufferIncomingFunctionCall( const FunctionCall& fctCall );
+  static void processBufferedFunctionCalls();
 
-  static std::map<uint32_t, packet::FunctionCalls*> clientMap_;
+  static std::map<uint32_t, packet::FunctionCalls*> sClientMap_;
+  static std::vector<FunctionCall>                  sIncomingFunctionCallBuffer_;
 protected:
   FunctionCallManager();

code/trunk/src/libraries/network/NetworkFunction.h

@@ -139 +139 @@
 
     //
-    virtual void call(uint32_t objectID)=0;
-    virtual void call(uint32_t objectID, const MultiType& mt1)=0;
-    virtual void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2)=0;
-    virtual void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)=0;
-    virtual void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)=0;
-    virtual void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)=0;
+    virtual bool call(uint32_t objectID)=0;
+    virtual bool call(uint32_t objectID, const MultiType& mt1)=0;
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2)=0;
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)=0;
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)=0;
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)=0;
 
   private:
@@ -156 +156 @@
     NetworkMemberFunction(const FunctorMemberPtr<T>& functor, const std::string& name, const NetworkFunctionPointer& p);
 
-    inline void call(uint32_t objectID)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    inline bool call(uint32_t objectID)
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+      {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)));
-    }
-    inline void call(uint32_t objectID, const MultiType& mt1)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+        return true;
+      }
+      else
+        return false;
+    }
+    inline bool call(uint32_t objectID, const MultiType& mt1)
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+      {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1);
-    }
-    inline void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+        return true;
+      }
+      else
+        return false;
+    }
+    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2)
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+      {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2);
-    }
-    inline void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+        return true;
+      }
+      else
+        return false;
+    }
+    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+      {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3);
-    }
-    inline void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+        return true;
+      }
+      else
+        return false;
+    }
+    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+      {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3, mt4);
-    }
-    inline void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+        return true;
+      }
+      else
+        return false;
+    }
+    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+      {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3, mt4, mt5);
+        return true;
+      }
+      else
+        return false;
     }
 

code/trunk/src/libraries/network/packet/FunctionCalls.cc

@@ -31 +31 @@
 #include <cassert>
 #include "network/FunctionCall.h"
+#include "network/FunctionCallManager.h"
 
 namespace orxonox {
@@ -66 +67 @@
     FunctionCall fctCall;
     fctCall.loadData(temp);
-    fctCall.execute();
+    if( !fctCall.execute() )
+      FunctionCallManager::bufferIncomingFunctionCall( fctCall );
   }