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

Timestamp:

Jan 17, 2016, 10:29:21 PM (8 years ago)

Author:

landauf

Message:

merged branch cpp11_v3 back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/network/synchronisable/NetworkCallback.h (modified) (2 diffs)
• src/libraries/network/synchronisable/Serialise.h (modified) (2 diffs)
• src/libraries/network/synchronisable/Synchronisable.cc (modified) (11 diffs)
• src/libraries/network/synchronisable/Synchronisable.h (modified) (6 diffs)
• src/libraries/network/synchronisable/SynchronisableVariable.h (modified) (2 diffs)

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

@@ -53 +53 @@
       NetworkCallback(T* object, void (T::*function) (void)) : object_(object), function_(function) {}
       virtual ~NetworkCallback() {}
-      virtual void call()
+      virtual void call() override
         { (this->object_->*function_)(); }
 
@@ -68 +68 @@
       NetworkCallbackNotify() {}
       virtual ~NetworkCallbackNotify() {}
-      virtual void call()
+      virtual void call() override
         { (this->object_->*function_)( this->oldValue_ ); }
       void setOldValue(const U& value){ this->oldValue_ = value; }

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

@@ -90 +90 @@
     {
 //         *const_cast<typename Loki::TypeTraits<T*>::UnqualifiedType*>(&variable) = dynamic_cast<T*>(variable->getSynchronisable( *(uint32_t*)(mem) ));
-        *const_cast<typename Loki::TypeTraits<StrongPtr<T> >::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
+        *const_cast<typename Loki::TypeTraits<StrongPtr<T>>::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
         mem += returnSize( variable );
     }
@@ -125 +125 @@
     {
         //         *const_cast<typename Loki::TypeTraits<T*>::UnqualifiedType*>(&variable) = dynamic_cast<T*>(variable->getSynchronisable( *(uint32_t*)(mem) ));
-        *const_cast<typename Loki::TypeTraits<WeakPtr<T> >::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
+        *const_cast<typename Loki::TypeTraits<WeakPtr<T>>::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
         mem += returnSize( variable );
     }

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

@@ -88 +88 @@
     }
     // delete all Synchronisable Variables from syncList_ ( which are also in stringList_ )
-    for(std::vector<SynchronisableVariableBase*>::iterator it = syncList_.begin(); it!=syncList_.end(); it++)
-      delete (*it);
+    for(SynchronisableVariableBase* variable : syncList_)
+      delete variable;
     syncList_.clear();
     stringList_.clear();
@@ -105 +105 @@
   uint32_t Synchronisable::findContextID(Context* context)
   {
-      if (context == NULL)
+      if (context == nullptr)
           return OBJECTID_UNKNOWN;
 
       Synchronisable* synchronisableContext = orxonox_cast<Synchronisable*>(context);
-      if (synchronisableContext != NULL)
+      if (synchronisableContext != nullptr)
           return synchronisableContext->getObjectID();
       else
@@ -140 +140 @@
     {
       mem += header.getDataSize() + header.getSize();
-      return 0;
+      return nullptr;
     }
 //     assert( !header.isDiffed() );
@@ -156 +156 @@
     }
     assert(id);
-    Context* context = 0;
+    Context* context = nullptr;
     if (header.getContextID() != OBJECTID_UNKNOWN)
     {
@@ -164 +164 @@
         mem += header.getDataSize()+SynchronisableHeader::getSize(); //.TODO: this suckz.... remove size from header
         assert(0); // TODO: uncomment this if we have a clean objecthierarchy (with destruction of children of objects) ^^
-        return 0;
+        return nullptr;
       }
       else
@@ -172 +172 @@
       context = Context::getRootContext();
 
-    assert(getSynchronisable(header.getObjectID())==0);   //make sure no object with this id exists
+    assert(getSynchronisable(header.getObjectID())==nullptr);   //make sure no object with this id exists
     BaseObject *bo = orxonox_cast<BaseObject*>(id->fabricate(context));
     assert(bo);
@@ -226 +226 @@
       return it1->second;
     // if the objects not in the map it should'nt exist at all anymore
-    return NULL;
+    return nullptr;
   }
 
@@ -266 +266 @@
     assert(this->classID_==this->getIdentifier()->getNetworkID());
     assert(this->objectID_!=OBJECTID_UNKNOWN);
-    std::vector<SynchronisableVariableBase*>::iterator i;
 
     // start copy header
@@ -276 +275 @@
 //     orxout(verbose, context::network) << "objectid: " << this->objectID_ << ":";
     // copy to location
-    for(i=syncList_.begin(); i!=syncList_.end(); ++i)
-    {
-      uint32_t varsize = (*i)->getData( mem, mode );
+    for(SynchronisableVariableBase* variable : syncList_)
+    {
+      uint32_t varsize = variable->getData( mem, mode );
 //       orxout(verbose, context::network) << " " << varsize;
       tempsize += varsize;
@@ -348 +347 @@
       assert( this->getContextID() == syncHeader2.getContextID() );
       mem += SynchronisableHeader::getSize();
-      std::vector<SynchronisableVariableBase *>::iterator i;
-      for(i=syncList_.begin(); i!=syncList_.end(); ++i)
+      for(SynchronisableVariableBase* variable : syncList_)
       {
         assert( mem <= data+syncHeader2.getDataSize()+SynchronisableHeader::getSize() ); // always make sure we don't exceed the datasize in our stream
-        (*i)->putData( mem, mode, forceCallback );
+        variable->putData( mem, mode, forceCallback );
       }
       assert(mem == data+syncHeaderLight.getDataSize()+SynchronisableHeader::getSize() );
@@ -388 +386 @@
     assert( mode==state_ );
     tsize += this->dataSize_;
-    std::vector<SynchronisableVariableBase*>::iterator i;
-    for(i=stringList_.begin(); i!=stringList_.end(); ++i)
-    {
-      tsize += (*i)->getSize( mode );
+    for(SynchronisableVariableBase* variable : stringList_)
+    {
+      tsize += variable->getSize( mode );
     }
     return tsize;

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

@@ -38 +38 @@
 #include <queue>
 #include <set>
+#include <type_traits>
 
 #include "util/mbool.h"
@@ -171 +172 @@
   protected:
     Synchronisable(Context* context);
-    template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
-    template <class T> void registerVariable(std::set<T>& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
+    template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=nullptr, bool bidirectional=false);
+    template <class T> void registerVariable(std::set<T>& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=nullptr, bool bidirectional=false);
     template <class T> void unregisterVariable(T& var);
 
@@ -203 +204 @@
   };
 
-  template <class T> void Synchronisable::registerVariable(T& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
-  {
+  namespace detail
+  {
+    template <class T, bool = std::is_enum<T>::value>
+    struct UnderlyingType;
+    template <class T>
+    struct UnderlyingType<T, true> { typedef typename std::underlying_type<T>::type type; };
+    template <class T>
+    struct UnderlyingType<T, false> { typedef T type; };
+  }
+
+  template <class T>
+  void Synchronisable::registerVariable(T& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
+  {
+    typedef typename detail::UnderlyingType<T>::type UnderlyingType;
     if (bidirectional)
     {
-      syncList_.push_back(new SynchronisableVariableBidirectional<T>(variable, mode, cb));
+      syncList_.push_back(new SynchronisableVariableBidirectional<UnderlyingType>(reinterpret_cast<UnderlyingType&>(variable), mode, cb));
       this->dataSize_ += syncList_.back()->getSize(state_);
     }
     else
     {
-      syncList_.push_back(new SynchronisableVariable<T>(variable, mode, cb));
+      syncList_.push_back(new SynchronisableVariable<UnderlyingType>(reinterpret_cast<UnderlyingType&>(variable), mode, cb));
       if ( this->state_ == mode )
         this->dataSize_ += syncList_.back()->getSize(state_);
@@ -218 +231 @@
   }
   
-  template <class T> void Synchronisable::unregisterVariable(T& variable)
+  template <class T>
+  void Synchronisable::unregisterVariable(T& variable)
   {
     std::vector<SynchronisableVariableBase*>::iterator it = syncList_.begin();
@@ -238 +252 @@
   }
 
-  template <class T> void Synchronisable::registerVariable( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
-  {
+  template <class T>
+  void Synchronisable::registerVariable( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
+  {
+    typedef typename detail::UnderlyingType<T>::type UnderlyingType;
     SynchronisableVariableBase* sv;
     if (bidirectional)
-      sv = new SynchronisableVariableBidirectional<std::set<T> >(variable, mode, cb);
+      sv = new SynchronisableVariableBidirectional<std::set<UnderlyingType>>(reinterpret_cast<std::set<UnderlyingType>&>(variable), mode, cb);
     else
-      sv = new SynchronisableVariable<std::set<T> >(variable, mode, cb);
+      sv = new SynchronisableVariable<std::set<UnderlyingType>>(reinterpret_cast<std::set<UnderlyingType>&>(variable), mode, cb);
     syncList_.push_back(sv);
     stringList_.push_back(sv);
@@ -250 +266 @@
 
   template <> _NetworkExport void Synchronisable::registerVariable( std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
-//   template <class T> _NetworkExport void Synchronisable::registerVariable<std::set<T> >( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
+//   template <class T> _NetworkExport void Synchronisable::registerVariable<std::set<T>>( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
   template <> _NetworkExport void Synchronisable::unregisterVariable( std::string& variable );
 

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

@@ -71 +71 @@
   {
     public:
-      SynchronisableVariable(T& variable, uint8_t syncDirection=VariableDirection::ToClient, NetworkCallbackBase *cb=0);
+      SynchronisableVariable(T& variable, uint8_t syncDirection=VariableDirection::ToClient, NetworkCallbackBase *cb=nullptr);
       virtual ~SynchronisableVariable();
 
-      virtual inline uint8_t getMode(){ return mode_; }
-      virtual inline uint32_t getData(uint8_t*& mem, uint8_t mode);
-      virtual inline void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false);
-      virtual inline uint32_t getSize(uint8_t mode);
-      virtual inline void* getReference(){ return static_cast<void*>(const_cast<typename Loki::TypeTraits<T>::UnqualifiedType*>(&this->variable_)); }
+      virtual inline uint8_t getMode() override{ return mode_; }
+      virtual inline uint32_t getData(uint8_t*& mem, uint8_t mode) override;
+      virtual inline void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false) override;
+      virtual inline uint32_t getSize(uint8_t mode) override;
+      virtual inline void* getReference() override{ return static_cast<void*>(const_cast<typename Loki::TypeTraits<T>::UnqualifiedType*>(&this->variable_)); }
     protected:
       T&                       variable_;
@@ -89 +89 @@
   {
     public:
-      SynchronisableVariableBidirectional(T& variable, uint8_t master=Bidirectionality::ServerMaster, NetworkCallbackBase *cb=0);
+      SynchronisableVariableBidirectional(T& variable, uint8_t master=Bidirectionality::ServerMaster, NetworkCallbackBase *cb=nullptr);
       virtual ~SynchronisableVariableBidirectional();