Changeset 11054 for code/branches/cpp11_v3/src/libraries/network

Timestamp:

Jan 10, 2016, 1:54:11 PM (8 years ago)

Author:

landauf

Message:

merged branch cpp11_v2 into cpp11_v3

Location:

code/branches/cpp11_v3

Files:

• . (modified) (1 prop)
• src/libraries/network/Client.cc (modified) (1 diff)
• src/libraries/network/Client.h (modified) (1 diff)
• src/libraries/network/ClientConnection.cc (modified) (3 diffs)
• src/libraries/network/ClientConnection.h (modified) (1 diff)
• src/libraries/network/ClientConnectionListener.cc (modified) (1 diff)
• src/libraries/network/Connection.cc (modified) (6 diffs)
• src/libraries/network/Connection.h (modified) (1 diff)
• src/libraries/network/FunctionCall.cc (modified) (3 diffs)
• src/libraries/network/FunctionCallManager.cc (modified) (3 diffs)
• src/libraries/network/FunctionCallManager.h (modified) (1 diff)
• src/libraries/network/GamestateHandler.cc (modified) (1 diff)
• src/libraries/network/GamestateManager.cc (modified) (10 diffs)
• src/libraries/network/GamestateManager.h (modified) (3 diffs)
• src/libraries/network/Host.cc (modified) (9 diffs)
• src/libraries/network/LANDiscoverable.cc (modified) (2 diffs)
• src/libraries/network/LANDiscovery.cc (modified) (3 diffs)
• src/libraries/network/MasterServer.cc (modified) (6 diffs)
• src/libraries/network/MasterServerComm.cc (modified) (5 diffs)
• src/libraries/network/NetworkFunction.h (modified) (8 diffs)
• src/libraries/network/NetworkFunctionIncludes.h (modified) (4 diffs)
• src/libraries/network/NetworkFunctionManager.cc (modified) (2 diffs)
• src/libraries/network/NetworkPrereqs.h (modified) (1 diff)
• src/libraries/network/NetworkStaticInitializationHandler.h (modified) (1 diff)
• src/libraries/network/PeerList.cc (modified) (3 diffs)
• src/libraries/network/Server.cc (modified) (5 diffs)
• src/libraries/network/Server.h (modified) (3 diffs)
• src/libraries/network/ServerConnection.cc (modified) (1 diff)
• src/libraries/network/TrafficControl.cc (modified) (9 diffs)
• src/libraries/network/TrafficControl.h (modified) (3 diffs)
• src/libraries/network/packet/Acknowledgement.h (modified) (1 diff)
• src/libraries/network/packet/Chat.h (modified) (1 diff)
• src/libraries/network/packet/ClassID.cc (modified) (2 diffs)
• src/libraries/network/packet/ClassID.h (modified) (1 diff)
• src/libraries/network/packet/DeleteObjects.h (modified) (1 diff)
• src/libraries/network/packet/FunctionCalls.h (modified) (1 diff)
• src/libraries/network/packet/FunctionIDs.cc (modified) (1 diff)
• src/libraries/network/packet/FunctionIDs.h (modified) (1 diff)
• src/libraries/network/packet/Gamestate.cc (modified) (9 diffs)
• src/libraries/network/packet/Gamestate.h (modified) (2 diffs)
• src/libraries/network/packet/Packet.cc (modified) (9 diffs)
• src/libraries/network/packet/ServerInformation.cc (modified) (1 diff)
• src/libraries/network/packet/ServerInformation.h (modified) (2 diffs)
• src/libraries/network/packet/Welcome.h (modified) (1 diff)
• 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) (3 diffs)
• src/libraries/network/synchronisable/SynchronisableVariable.h (modified) (2 diffs)

code/branches/cpp11_v3/src/libraries/network/Client.cc

@@ -161 +161 @@
         {
           std::vector<packet::Gamestate*> gamestates = GamestateManager::getGamestates();
-          std::vector<packet::Gamestate*>::iterator it;
-          for( it = gamestates.begin(); it != gamestates.end(); ++it )
+          for( packet::Gamestate* gamestate : gamestates )
           {
-            (*it)->send( static_cast<Host*>(this) );
+            gamestate->send( static_cast<Host*>(this) );
           }
         }

code/branches/cpp11_v3/src/libraries/network/Client.h

@@ -76 +76 @@
     static Client* getInstance(){ return singletonPtr_s; } // tolua_export
 
-    bool establishConnection();
+    virtual bool establishConnection() override;
     void setDestination( const std::string& serverAddress, unsigned int port ); // tolua_export
-    bool closeConnection();
-    void queuePacket(ENetPacket* packet, int clientID, uint8_t channelID);
-    virtual bool sendPacket( packet::Packet* packet ){ return packet->send( static_cast<Host*>(this) ); }
-    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
-    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
-    virtual void printRTT();
+    virtual bool closeConnection() override;
+    virtual void queuePacket(ENetPacket* packet, int clientID, uint8_t channelID) override;
+    virtual bool sendPacket( packet::Packet* packet ) override{ return packet->send( static_cast<Host*>(this) ); }
+    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID) override;
+    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID) override;
+    virtual void printRTT() override;
 
     void update(const Clock& time);
   protected:
-    virtual void connectionClosed();
+    virtual void connectionClosed() override;
   private:
     Client(const Client& copy); // not used
-    virtual bool isServer_(){return false;}
-    void processPacket(packet::Packet* packet);
+    virtual bool isServer_() override{return false;}
+    virtual void processPacket(packet::Packet* packet) override;
 
     static Client* singletonPtr_s;

code/branches/cpp11_v3/src/libraries/network/ClientConnection.cc

@@ -44 +44 @@
     Connection(NETWORK_PEER_ID_SERVER),
     established_(false),
-    server_(NULL)
+    server_(nullptr)
   {
     this->serverAddress_ = new ENetAddress();
@@ -72 +72 @@
 
     // create host
-    this->host_ = enet_host_create(NULL, NETWORK_CLIENT_MAX_CONNECTIONS, NETWORK_CHANNEL_COUNT, 0, 0);
+    this->host_ = enet_host_create(nullptr, NETWORK_CLIENT_MAX_CONNECTIONS, NETWORK_CHANNEL_COUNT, 0, 0);
     
-    if ( this->host_ == NULL )
+    if ( this->host_ == nullptr )
     {
-      orxout(internal_error, context::network) << "ClientConnection: host_ == NULL" << endl;
+      orxout(internal_error, context::network) << "ClientConnection: host_ == nullptr" << endl;
       // error handling
       return false;
@@ -93 +93 @@
 
     this->server_ = enet_host_connect(this->host_, serverAddress_, NETWORK_CHANNEL_COUNT, 0);
-    if ( this->server_==NULL )
+    if ( this->server_==nullptr )
     {
-      orxout(internal_error, context::network) << "ClientConnection: server_ == NULL" << endl;
+      orxout(internal_error, context::network) << "ClientConnection: server_ == nullptr" << endl;
       // error handling
       return false;

code/branches/cpp11_v3/src/libraries/network/ClientConnection.h

@@ -57 +57 @@
     uint32_t getRTT();
   private:
-    virtual void addPeer(uint32_t peerID);
-    virtual void removePeer(uint32_t peerID);
+    virtual void addPeer(uint32_t peerID) override;
+    virtual void removePeer(uint32_t peerID) override;
 
     bool disconnectConnection();

code/branches/cpp11_v3/src/libraries/network/ClientConnectionListener.cc

@@ -44 +44 @@
     void ClientConnectionListener::broadcastClientConnected(unsigned int clientID)
     {
-        for (ObjectList<ClientConnectionListener>::iterator it = ObjectList<ClientConnectionListener>::begin(); it != ObjectList<ClientConnectionListener>::end(); ++it)
-            it->clientConnected(clientID);
+        for (ClientConnectionListener* listener : ObjectList<ClientConnectionListener>())
+            listener->clientConnected(clientID);
     }
 
     void ClientConnectionListener::broadcastClientDisconnected(unsigned int clientID)
     {
-        for (ObjectList<ClientConnectionListener>::iterator it = ObjectList<ClientConnectionListener>::begin(); it != ObjectList<ClientConnectionListener>::end(); ++it)
-            it->clientDisconnected(clientID);
+        for (ClientConnectionListener* listener : ObjectList<ClientConnectionListener>())
+            listener->clientDisconnected(clientID);
     }
 

code/branches/cpp11_v3/src/libraries/network/Connection.cc

@@ -46 +46 @@
 
   Connection::Connection(uint32_t firstPeerID):
-    host_(0), bCommunicationThreadRunning_(false), nextPeerID_(firstPeerID)
+    host_(nullptr), bCommunicationThreadRunning_(false), nextPeerID_(firstPeerID)
   {
     enet_initialize();
@@ -81 +81 @@
   {
 //     this->overallMutex_->lock();
-    outgoingEvent outEvent = { peerID, outgoingEventType::disconnectPeer, 0, 0 };
+    outgoingEvent outEvent = { peerID, outgoingEventType::disconnectPeer, nullptr, 0 };
     
     this->outgoingEventsMutex_->lock();
@@ -91 +91 @@
   void Connection::disconnectPeers()
   {
-    outgoingEvent outEvent = { 0, outgoingEventType::disconnectPeers, 0, 0 };
+    outgoingEvent outEvent = { 0, outgoingEventType::disconnectPeers, nullptr, 0 };
     
     this->outgoingEventsMutex_->lock();
@@ -237 +237 @@
   void Connection::disconnectPeersInternal()
   {
-    std::map<uint32_t, ENetPeer*>::iterator it;
-    for( it=this->peerMap_.begin(); it!=this->peerMap_.end(); ++it )
-    {
-      enet_peer_disconnect(it->second, 0);
+    for( const auto& mapEntry : this->peerMap_ )
+    {
+      enet_peer_disconnect(mapEntry.second, 0);
     }
     uint32_t iterations = NETWORK_DISCONNECT_TIMEOUT/NETWORK_WAIT_TIMEOUT;
@@ -323 +322 @@
     
     // create new peerEvent and return it
-    incomingEvent inEvent = { peerID, incomingEventType::peerConnect, 0 };
+    incomingEvent inEvent = { peerID, incomingEventType::peerConnect, nullptr };
     return inEvent;
   }
@@ -338 +337 @@
     
     // create new peerEvent and return it
-    incomingEvent inEvent = { peerID, incomingEventType::peerDisconnect, 0 };
+    incomingEvent inEvent = { peerID, incomingEventType::peerDisconnect, nullptr };
     return inEvent;
   }

code/branches/cpp11_v3/src/libraries/network/Connection.h

@@ -46 +46 @@
 #include <map>
 #include <enet/enet.h>
-#include <boost/concept_check.hpp>
 
 namespace boost

code/branches/cpp11_v3/src/libraries/network/FunctionCall.cc

@@ -48 +48 @@
 bool FunctionCall::execute(){
   NetworkFunctionBase* fct = NetworkFunctionManager::getInstance().getFunctionByNetworkId( this->functionID_ );
-  assert( fct != NULL );
+  assert( fct != nullptr );
   assert( this->nrOfArguments_==this->arguments_.size() );
   switch(this->nrOfArguments_)
@@ -119 +119 @@
   for( unsigned int i=0; i<this->nrOfArguments_; ++i )
   {
-    this->arguments_.push_back(MultiType());
+    this->arguments_.emplace_back();
     this->arguments_.back().importData(mem);
   }
@@ -131 +131 @@
   *(uint32_t*)(mem+2*sizeof(uint32_t)) = this->objectID_;
   mem += 3*sizeof(uint32_t);
-  for( std::vector<MultiType>::iterator it = this->arguments_.begin(); it!=this->arguments_.end(); ++it )
+  for(const MultiType& argument : this->arguments_)
   {
-    it->exportData( mem );
+    argument.exportData( mem );
   }
 }

code/branches/cpp11_v3/src/libraries/network/FunctionCallManager.cc

@@ -37 +37 @@
 
 std::map<uint32_t, packet::FunctionCalls*> FunctionCallManager::sPeerMap_;
-std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t> > > FunctionCallManager::sIncomingFunctionCallBuffer_;
+std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t>>> FunctionCallManager::sIncomingFunctionCallBuffer_;
 
 
@@ -54 +54 @@
 void FunctionCallManager::sendCalls(orxonox::Host* host)
 {
-  std::map<uint32_t, packet::FunctionCalls*>::iterator it;
-  for (it = FunctionCallManager::sPeerMap_.begin(); it != FunctionCallManager::sPeerMap_.end(); ++it )
+  for (const auto& mapEntry : FunctionCallManager::sPeerMap_ )
   {
     assert(!FunctionCallManager::sPeerMap_.empty());
-    it->second->send(host);
+    mapEntry.second->send(host);
   }
   FunctionCallManager::sPeerMap_.clear();
@@ -65 +64 @@
 void FunctionCallManager::bufferIncomingFunctionCall(const orxonox::FunctionCall& fctCall, uint32_t minGamestateID, uint32_t peerID)
 {
-  FunctionCallManager::sIncomingFunctionCallBuffer_.push_back( std::make_pair(fctCall, std::make_pair(minGamestateID, peerID)));
+  FunctionCallManager::sIncomingFunctionCallBuffer_.emplace_back(fctCall, std::make_pair(minGamestateID, peerID));
 }
 
 void FunctionCallManager::processBufferedFunctionCalls()
 {
-  std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t> > >::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
+  std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t>>>::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
   while( it!=FunctionCallManager::sIncomingFunctionCallBuffer_.end() )
   {

code/branches/cpp11_v3/src/libraries/network/FunctionCallManager.h

@@ -54 +54 @@
 
   static std::map<uint32_t, packet::FunctionCalls*>                           sPeerMap_;
-  static std::vector<std::pair<FunctionCall,std::pair<uint32_t, uint32_t> > > sIncomingFunctionCallBuffer_;
+  static std::vector<std::pair<FunctionCall,std::pair<uint32_t, uint32_t>>> sIncomingFunctionCallBuffer_;
 protected:
   FunctionCallManager();

code/branches/cpp11_v3/src/libraries/network/GamestateHandler.cc

@@ -32 +32 @@
 namespace orxonox {
 
-// GamestateHandler *GamestateHandler::instance_=0;
+// GamestateHandler *GamestateHandler::instance_=nullptr;
 
 GamestateHandler::GamestateHandler()

code/branches/cpp11_v3/src/libraries/network/GamestateManager.cc

@@ -60 +60 @@
 { 
   GamestateManager::GamestateManager() :
-  currentGamestate_(0), id_(0)
+  currentGamestate_(nullptr), id_(0)
   {
 //     trafficControl_ = new TrafficControl();
@@ -70 +70 @@
   {
     if( this->currentGamestate_ )
-        delete this->currentGamestate_;std::map<unsigned int, packet::Gamestate*>::iterator it;
-    for( it = gamestateQueue.begin(); it != gamestateQueue.end(); ++it )
-      delete it->second;
-    std::map<uint32_t, peerInfo>::iterator peerIt;
-    std::map<uint32_t, packet::Gamestate*>::iterator gamestateIt;
-    for( peerIt = peerMap_.begin(); peerIt != peerMap_.end(); ++peerIt )
-    {
-      for( gamestateIt = peerIt->second.gamestates.begin(); gamestateIt != peerIt->second.gamestates.end(); ++gamestateIt )
-        delete gamestateIt->second;
+        delete this->currentGamestate_;
+    for( const auto& mapEntry : gamestateQueue )
+      delete mapEntry.second;
+    for( const auto& mapEntryPeer : peerMap_ )
+    {
+      for( const auto& mapEntryGamestate : mapEntryPeer.second.gamestates )
+        delete mapEntryGamestate.second;
     }
 //     this->trafficControl_->destroy();
@@ -107 +105 @@
     if( this->gamestateQueue.empty() )
         return true;
-    std::map<unsigned int, packet::Gamestate*>::iterator it;
     // now push only the most recent gamestates we received (ignore obsolete ones)
-    for(it = gamestateQueue.begin(); it!=gamestateQueue.end(); it++)
-    {
-      OrxVerify(processGamestate(it->second), "ERROR: could not process Gamestate");
-      sendAck( it->second->getID(), it->second->getPeerID() );
-      delete it->second;
+    for(const auto& mapEntry : gamestateQueue)
+    {
+      OrxVerify(processGamestate(mapEntry.second), "ERROR: could not process Gamestate");
+      sendAck( mapEntry.second->getID(), mapEntry.second->getPeerID() );
+      delete mapEntry.second;
     }
     // now clear the queue
@@ -140 +137 @@
 
   bool GamestateManager::getSnapshot(){
-    if ( currentGamestate_ != 0 )
+    if ( currentGamestate_ != nullptr )
       delete currentGamestate_;
     uint8_t gsMode;
@@ -165 +162 @@
     { //we have no data to send
       delete currentGamestate_;
-      currentGamestate_=0;
+      currentGamestate_=nullptr;
       return false;
     }
@@ -177 +174 @@
     std::vector<packet::Gamestate*> peerGamestates;
     
-    std::map<uint32_t, peerInfo>::iterator peerIt;
-    for( peerIt=peerMap_.begin(); peerIt!=peerMap_.end(); ++peerIt )
-    {
-      if( !peerIt->second.isSynched )
+    for( const auto& mapEntry : peerMap_ )
+    {
+      if( !mapEntry.second.isSynched )
       {
         orxout(verbose_more, context::network) << "Server: not sending gamestate" << endl;
         continue;
       }
-      orxout(verbose_more, context::network) << "client id: " << peerIt->first << endl;
+      orxout(verbose_more, context::network) << "client id: " << mapEntry.first << endl;
       orxout(verbose_more, context::network) << "Server: doing gamestate gamestate preparation" << endl;
-      int peerID = peerIt->first; //get client id
-
-      unsigned int lastAckedGamestateID = peerIt->second.lastAckedGamestateID;
-
-      packet::Gamestate* baseGamestate=0;
+      int peerID = mapEntry.first; //get client id
+
+      unsigned int lastAckedGamestateID = mapEntry.second.lastAckedGamestateID;
+
+      packet::Gamestate* baseGamestate=nullptr;
       if(lastAckedGamestateID != GAMESTATEID_INITIAL)
       {
@@ -200 +196 @@
       }
 
-      peerGamestates.push_back(0);  // insert an empty gamestate* to be changed
+      peerGamestates.push_back(nullptr);  // insert an empty gamestate* to be changed
       finishGamestate( peerID, peerGamestates.back(), baseGamestate, currentGamestate_ );
-      if( peerGamestates.back()==0 )
+      if( peerGamestates.back()==nullptr )
         // nothing to send to remove pointer from vector
         peerGamestates.pop_back();
@@ -243 +239 @@
       {
         delete diffed1;
-        destgamestate = 0;
+        destgamestate = nullptr;
         return;
       }
@@ -340 +336 @@
   {
     assert(peerMap_.find(peerID)!=peerMap_.end());
-    std::map<uint32_t, packet::Gamestate*>::iterator peerIt;
-    for( peerIt = peerMap_[peerID].gamestates.begin(); peerIt!=peerMap_[peerID].gamestates.end(); ++peerIt )
-    {
-      delete peerIt->second;
+    for( const auto& mapEntry : peerMap_[peerID].gamestates )
+    {
+      delete mapEntry.second;
     }
     peerMap_.erase(peerMap_.find(peerID));
@@ -351 +346 @@
 //   void GamestateManager::removeClient(ClientInformation* client){
 //     assert(client);
-//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> >::iterator clientMap = gamestateMap_.find(client->getID());
+//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*>>::iterator clientMap = gamestateMap_.find(client->getID());
 //     // first delete all remained gamestates
 //     std::map<unsigned int, packet::Gamestate*>::iterator it;

code/branches/cpp11_v3/src/libraries/network/GamestateManager.h

@@ -47 +47 @@
 #include "core/CorePrereqs.h"
 #include "packet/Gamestate.h"
-#include <boost/concept_check.hpp>
 
 namespace orxonox
@@ -84 +83 @@
     ~GamestateManager();
 
-    virtual bool      addGamestate(packet::Gamestate *gs, unsigned int peerID);
-    virtual bool      ackGamestate(unsigned int gamestateID, unsigned int peerID);
-    virtual uint32_t  getLastReceivedGamestateID( unsigned int peerID );
-    virtual uint32_t  getCurrentGamestateID(){ if( currentGamestate_) return currentGamestate_->getID(); else return GAMESTATEID_INITIAL; }
+    virtual bool      addGamestate(packet::Gamestate *gs, unsigned int peerID) override;
+    virtual bool      ackGamestate(unsigned int gamestateID, unsigned int peerID) override;
+    virtual uint32_t  getLastReceivedGamestateID( unsigned int peerID ) override;
+    virtual uint32_t  getCurrentGamestateID() override{ if( currentGamestate_) return currentGamestate_->getID(); else return GAMESTATEID_INITIAL; }
 
     bool processGamestates();
@@ -108 +107 @@
     bool processGamestate(packet::Gamestate *gs);
 
-//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> > gamestateMap_;
+//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*>> gamestateMap_;
     std::map<unsigned int, packet::Gamestate*> gamestateQueue;
 //     std::map<unsigned int, uint32_t> lastProcessedGamestateID_;

code/branches/cpp11_v3/src/libraries/network/Host.cc

@@ -44 +44 @@
   SetConsoleCommand(__CC_printRTT_group, __CC_printRTT_name, &Host::printRTT);
 
-  // Host*               Host::instance_=0;
+  // Host*               Host::instance_=nullptr;
   uint32_t            Host::clientID_s=0;
 //   uint32_t            Host::shipID_s=-1;
@@ -54 +54 @@
   Host::Host()
   {
-  //   assert(instance_==0);
+  //   assert(instance_==nullptr);
     instances_s.push_back(this);
     ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(this);
@@ -62 +62 @@
 
   /**
-  * @brief Destructor: resets the instance pointer to 0
+  * @brief Destructor: resets the instance pointer to nullptr
   */
   Host::~Host()
@@ -68 +68 @@
     assert( std::find( instances_s.begin(), instances_s.end(), this )!=instances_s.end() );
     instances_s.erase(std::find( instances_s.begin(), instances_s.end(), this ));
-    ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(0);
+    ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(nullptr);
   }
 
@@ -80 +80 @@
   void Host::addPacket(ENetPacket *packet, int clientID, uint8_t channelID)
   {
-    for( std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it )
+    for(Host* host : instances_s)
     {
-      if( (*it)->isActive() )
+      if( host->isActive() )
       {
-        (*it)->queuePacket(packet, clientID, channelID);
+        host->queuePacket(packet, clientID, channelID);
       }
     }
@@ -97 +97 @@
   void Host::sendChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
   {
-    for( std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it )
-      if( (*it)->isActive() )
-        (*it)->doSendChat(message, sourceID, targetID);
+    for(Host* host : instances_s)
+      if( host->isActive() )
+        host->doSendChat(message, sourceID, targetID);
   }
 
@@ -107 +107 @@
   void Host::doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
   {
-    for (ObjectList<NetworkChatListener>::iterator it = ObjectList<NetworkChatListener>::begin(); it != ObjectList<NetworkChatListener>::end(); ++it)
-      it->incomingChat(message, sourceID);
+    for (NetworkChatListener* listener : ObjectList<NetworkChatListener>())
+      listener->incomingChat(message, sourceID);
   }
 
@@ -114 +114 @@
   bool Host::isServer()
   {
-    for (std::vector<Host*>::iterator it=instances_s.begin(); it!=instances_s.end(); ++it )
+    for (Host* host : instances_s)
     {
-      if( (*it)->isActive() )
+      if( host->isActive() )
       {
-        if( (*it)->isServer_() )
+        if( host->isServer_() )
           return true;
       }
@@ -135 +135 @@
         ++it;
     }
-    return 0;
+    return nullptr;
   }
 

code/branches/cpp11_v3/src/libraries/network/LANDiscoverable.cc

@@ -46 +46 @@
   RegisterClassNoArgs(LANDiscoverable);
 
-  LANDiscoverable::LANDiscoverable() : bActive_(false), host_(0)
+  LANDiscoverable::LANDiscoverable() : bActive_(false), host_(nullptr)
   {
     /* register object in orxonox */
@@ -82 +82 @@
       bindAddress.host = ENET_HOST_ANY;
       bindAddress.port = LAN_DISCOVERY_PORT;
-      assert( this->host_ == 0 );
+      assert( this->host_ == nullptr );
       this->host_ = enet_host_create( &bindAddress, 10, 0, 0, 0 );
-      if ( this->host_ == NULL )
-          orxout(internal_error, context::network) << "LANDiscoverable: host_ == NULL" << endl;
+      if ( this->host_ == nullptr )
+          orxout(internal_error, context::network) << "LANDiscoverable: host_ == nullptr" << endl;
     }
     else
     {
       enet_host_destroy( this->host_ );
-      this->host_ = 0;
+      this->host_ = nullptr;
     }
       this->bActive_ = bActive;

code/branches/cpp11_v3/src/libraries/network/LANDiscovery.cc

@@ -42 +42 @@
   LANDiscovery::LANDiscovery()
   {
-    this->host_ = enet_host_create(NULL, 10, 0, 0, 0 );
-    if ( this->host_ == NULL )
-        orxout(internal_error, context::network) << "LANDiscovery: host_ == NULL" << endl;
+    this->host_ = enet_host_create(nullptr, 10, 0, 0, 0 );
+    if ( this->host_ == nullptr )
+        orxout(internal_error, context::network) << "LANDiscovery: host_ == nullptr" << endl;
   }
 
   LANDiscovery::~LANDiscovery()
   {
-    if (this->host_ != NULL)
+    if (this->host_ != nullptr)
       enet_host_destroy(this->host_);
   }
@@ -65 +65 @@
     address.host = ENET_HOST_BROADCAST;
     peer = enet_host_connect(this->host_, &address, 0, 0);
-    if (peer == NULL)
+    if (peer == nullptr)
         orxout(internal_error, context::network) << "Could not send LAN discovery to IPv4 Broadcast." << endl;
 
@@ -71 +71 @@
     enet_address_set_host(&address, "ff02::1"); // TODO: use a multicast group
     peer = enet_host_connect(this->host_, &address, 0, 0);
-    if (peer == NULL)
+    if (peer == nullptr)
         orxout(internal_error, context::network) << "Could not send LAN discovery to IPv6 Multicast." << endl;
 

code/branches/cpp11_v3/src/libraries/network/MasterServer.cc

@@ -43 +43 @@
 
   /* forward declaration so the linker doesn't complain */
-  MasterServer *MasterServer::instance = NULL;
+  MasterServer *MasterServer::instance = nullptr;
 
   /* command: list servers */
@@ -49 +49 @@
   MasterServer::listServers( void )
   {
-    /* get an iterator */
-    std::list<ServerListElem>::iterator i;
-
     /* print list header */
     orxout(user_info) << "List of connected servers" << std::endl;
 
     /* loop through list elements */
-    for( i = MasterServer::getInstance()->mainlist.serverlist.begin();
-      i != MasterServer::getInstance()->mainlist.serverlist.end(); ++i )
+    for( const ServerListElem& elem : MasterServer::getInstance()->mainlist.serverlist )
     {
-      orxout(user_info) << "  " << (*i).ServerInfo.getServerIP() << std::endl;
+      orxout(user_info) << "  " << elem.ServerInfo.getServerIP() << std::endl;
     }
 
@@ -112 +108 @@
   MasterServer::helper_sendlist( ENetEvent *event )
   {
-    /* get an iterator */
-    std::list<ServerListElem>::iterator i;
-
     /* packet holder */
     ENetPacket *reply;
 
     /* loop through list elements */
-    for( i = mainlist.serverlist.begin(); i
-        != mainlist.serverlist.end(); ++i )
+    for( const ServerListElem& elem : mainlist.serverlist )
     {
       /* send this particular server */
       /* build reply string */
-      int packetlen = MSPROTO_SERVERLIST_ITEM_LEN + 1 + (*i).ServerInfo.getServerIP().length() + 1 + (*i).ServerInfo.getServerName().length() + 1 + sizeof((*i).ServerInfo.getClientNumber()) + 1;
+      int packetlen = MSPROTO_SERVERLIST_ITEM_LEN + 1 + elem.ServerInfo.getServerIP().length() + 1 + elem.ServerInfo.getServerName().length() + 1 + sizeof(elem.ServerInfo.getClientNumber()) + 1;
       char *tosend = (char *)calloc(packetlen ,1 );
       if( !tosend )
@@ -131 +123 @@
       }
       sprintf( tosend, "%s %s %s %u", MSPROTO_SERVERLIST_ITEM,
-          (*i).ServerInfo.getServerIP().c_str(), (*i).ServerInfo.getServerName().c_str(), (*i).ServerInfo.getClientNumber());
+          elem.ServerInfo.getServerIP().c_str(), elem.ServerInfo.getServerName().c_str(), elem.ServerInfo.getClientNumber());
 
       /* create packet from it */
@@ -167 +159 @@
   MasterServer::helper_cleanupServers( void )
   {
-    /* get an iterator */
-    std::list<ServerListElem>::iterator i;
-
     if( mainlist.serverlist.size() == 0 )
       return;
 
     /* loop through list elements */
-    for( i = mainlist.serverlist.begin(); i
-        != mainlist.serverlist.end(); ++i )
+    for( const ServerListElem& elem : mainlist.serverlist )
     { /* see if we have a disconnected peer */
-      if( (*i).peer &&
-         ((*i).peer->state == ENET_PEER_STATE_DISCONNECTED ||
-          (*i).peer->state == ENET_PEER_STATE_ZOMBIE ))
+      if( elem.peer &&
+         (elem.peer->state == ENET_PEER_STATE_DISCONNECTED ||
+          elem.peer->state == ENET_PEER_STATE_ZOMBIE ))
       {
         /* Remove it from the list */
-        orxout(internal_warning) << (char*)(*i).peer->data << " timed out.\n";
-        mainlist.delServerByName( (*i).ServerInfo.getServerName() );
+        orxout(internal_warning) << (char*)elem.peer->data << " timed out.\n";
+        mainlist.delServerByName( elem.ServerInfo.getServerName() );
 
         /* stop iterating, we manipulated the list */
@@ -345 +333 @@
     /***** ENTER MAIN LOOP *****/
     ENetEvent *event = (ENetEvent *)calloc(sizeof(ENetEvent), sizeof(char));
-    if( event == NULL )
+    if( event == nullptr )
     {
       orxout(user_error, context::master_server) << "Could not create ENetEvent structure, exiting." << endl;

code/branches/cpp11_v3/src/libraries/network/MasterServerComm.cc

@@ -54 +54 @@
 
     /* initiate the client */
-    this->client = enet_host_create( NULL /* create a client host */,
+    this->client = enet_host_create( nullptr /* create a client host */,
         1,
         2, /* allow up 2 channels to be used, 0 and 1 */
@@ -61 +61 @@
 
     /* see if it worked */
-    if (this->client == NULL)
+    if (this->client == nullptr)
     { orxout(internal_error, context::master_server) << "An error occurred while trying to create an " 
         << "ENet client host." << endl;
@@ -85 +85 @@
     this->peer = enet_host_connect(this->client, &this->address, 2, 0);    
 
-    if( this->peer == NULL )
+    if( this->peer == nullptr )
     { orxout(internal_error, context::master_server) << "No available peers for initiating an ENet"
         << " connection." << endl;
@@ -157 +157 @@
 
     /* address buffer */
-    char *addrconv = NULL;
+    char *addrconv = nullptr;
     int retval = 0;
 
@@ -193 +193 @@
 
           /* call the supplied callback, if any. */
-          if( listener != NULL )
+          if( listener != nullptr )
             retval = listener->rhandler( addrconv, &(this->event) );
 

code/branches/cpp11_v3/src/libraries/network/NetworkFunction.h

@@ -45 +45 @@
 
 #if defined(ORXONOX_COMPILER_GCC) && defined(ORXONOX_ARCH_32)
-static const unsigned int MAX_FUNCTION_POINTER_SIZE = 8;
+static constexpr unsigned int MAX_FUNCTION_POINTER_SIZE = 8;
 #else
-static const unsigned int MAX_FUNCTION_POINTER_SIZE = 16;
+static constexpr unsigned int MAX_FUNCTION_POINTER_SIZE = 16;
 #endif //ORXONOX_COMPILER_GCC
-static const unsigned int MAX_FUNCTION_POINTER_INTS = (MAX_FUNCTION_POINTER_SIZE-1)/4+1;
+static constexpr unsigned int MAX_FUNCTION_POINTER_INTS = (MAX_FUNCTION_POINTER_SIZE-1)/4+1;
 
 struct _NetworkExport NetworkFunctionPointer {
@@ -114 +114 @@
 
     // ignore the objectID because its a static function
-    virtual bool call(uint32_t objectID){ (*this->functor_)(); return true; }
-    virtual bool call(uint32_t objectID, const MultiType& mt1){ (*this->functor_)(mt1); return true; }
-    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2){ (*this->functor_)(mt1, mt2); return true; }
-    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3){ (*this->functor_)(mt1, mt2, mt3); return true; }
-    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4){ (*this->functor_)(mt1, mt2, mt3, mt4); return true; }
-    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5){ (*this->functor_)(mt1, mt2, mt3, mt4, mt5); return true; }
+    virtual bool call(uint32_t objectID) override{ (*this->functor_)(); return true; }
+    virtual bool call(uint32_t objectID, const MultiType& mt1) override{ (*this->functor_)(mt1); return true; }
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2) override{ (*this->functor_)(mt1, mt2); return true; }
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3) override{ (*this->functor_)(mt1, mt2, mt3); return true; }
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4) override{ (*this->functor_)(mt1, mt2, mt3, mt4); return true; }
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5) override{ (*this->functor_)(mt1, mt2, mt3, mt4, mt5); return true; }
 
   private:
@@ -142 +142 @@
     { }
 
-    inline bool call(uint32_t objectID)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)));
@@ -152 +152 @@
         return false;
     }
-    inline bool call(uint32_t objectID, const MultiType& mt1)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID, const MultiType& mt1) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1);
@@ -162 +162 @@
         return false;
     }
-    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2);
@@ -172 +172 @@
         return false;
     }
-    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3);
@@ -182 +182 @@
         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 )
+    virtual inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3, mt4);
@@ -192 +192 @@
         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 )
+    virtual inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3, mt4, mt5);

code/branches/cpp11_v3/src/libraries/network/NetworkFunctionIncludes.h

@@ -33 +33 @@
 
 #include <boost/preprocessor/cat.hpp>
-#include <boost/static_assert.hpp>
 
 #include "NetworkFunction.h"
@@ -57 +56 @@
             ~StaticallyInitializedNetworkFunction() { delete function_; }
 
-            virtual void load();
-            virtual void unload();
+            virtual void load() override;
+            virtual void unload() override;
 
             inline NetworkFunctionBase& getFunction()
@@ -72 +71 @@
     inline NetworkFunctionBase* registerStaticNetworkFunctionFct(PT ptr, const std::string& name)
     {
-        BOOST_STATIC_ASSERT(sizeof(PT) <= sizeof(NetworkFunctionPointer)); // if this fails your compiler uses bigger pointers for static functions than defined above
+        static_assert(sizeof(PT) <= sizeof(NetworkFunctionPointer), "check pointer size"); // if this fails your compiler uses bigger pointers for static functions than defined above
         NetworkFunctionPointer destptr;
         copyPtr(ptr, destptr);
@@ -81 +80 @@
     inline NetworkFunctionBase* registerMemberNetworkFunctionFct(PT ptr, const std::string& name)
     {
-        BOOST_STATIC_ASSERT(sizeof(PT) <= sizeof(NetworkFunctionPointer)); // if this fails your compiler uses bigger pointers for a specific kind of member functions than defined above
+        static_assert(sizeof(PT) <= sizeof(NetworkFunctionPointer), "check pointer size"); // if this fails your compiler uses bigger pointers for a specific kind of member functions than defined above
         NetworkFunctionPointer destptr;
         copyPtr(ptr, destptr);

code/branches/cpp11_v3/src/libraries/network/NetworkFunctionManager.cc

@@ -32 +32 @@
 namespace orxonox
 {
-    NetworkFunctionManager* NetworkFunctionManager::singletonPtr_s = 0;
+    NetworkFunctionManager* NetworkFunctionManager::singletonPtr_s = nullptr;
 
     void NetworkFunctionManager::registerFunction(NetworkFunctionBase* function)
@@ -71 +71 @@
             return it->second;
         else
-            return NULL;
+            return nullptr;
     }
 

code/branches/cpp11_v3/src/libraries/network/NetworkPrereqs.h

@@ -67 +67 @@
 namespace orxonox
 {
-  static const unsigned int GAMESTATEID_INITIAL       = static_cast<unsigned int>(-1);
+  static constexpr unsigned int GAMESTATEID_INITIAL       = static_cast<unsigned int>(-1);
   extern const char* LAN_DISCOVERY_MESSAGE;
   extern const char* LAN_DISCOVERY_ACK;
-  static const unsigned int LAN_DISCOVERY_PORT          = 55558;
-  static const unsigned int NETWORK_PEER_ID_SERVER      = 0;
-  static const unsigned int NETWORK_PEER_ID_BROADCAST   = static_cast<unsigned int>(-1);
-  static const unsigned int NETWORK_PEER_ID_UNKNOWN     = static_cast<unsigned int>(-2);
-  static const unsigned int NETWORK_CHANNEL_DEFAULT     = 0;
-  static const unsigned int NETWORK_CHANNEL_UNRELIABLE  = 1;
-  static const unsigned int NETWORK_CHANNEL_COUNT       = 2;
+  static constexpr unsigned int LAN_DISCOVERY_PORT          = 55558;
+  static constexpr unsigned int NETWORK_PEER_ID_SERVER      = 0;
+  static constexpr unsigned int NETWORK_PEER_ID_BROADCAST   = static_cast<unsigned int>(-1);
+  static constexpr unsigned int NETWORK_PEER_ID_UNKNOWN     = static_cast<unsigned int>(-2);
+  static constexpr unsigned int NETWORK_CHANNEL_DEFAULT     = 0;
+  static constexpr unsigned int NETWORK_CHANNEL_UNRELIABLE  = 1;
+  static constexpr unsigned int NETWORK_CHANNEL_COUNT       = 2;
 }
 

code/branches/cpp11_v3/src/libraries/network/NetworkStaticInitializationHandler.h

@@ -39 +39 @@
     {
         public:
-            virtual void setupHandler();
-            virtual void shutdownHandler();
+            virtual void setupHandler() override;
+            virtual void shutdownHandler() override;
 
-            virtual void loadModule(ModuleInstance* module);
-            virtual void unloadModule(ModuleInstance* module);
+            virtual void loadModule(ModuleInstance* module) override;
+            virtual void unloadModule(ModuleInstance* module) override;
     };
 }

code/branches/cpp11_v3/src/libraries/network/PeerList.cc

@@ -41 +41 @@
   PeerList::addPeer( ENetPeer *toadd )
   { /* error correction */
-    if( toadd == NULL )
+    if( toadd == nullptr )
     { orxout(internal_error, context::master_server) << "PeerList::addPeer: empty peer given." << endl;
       return -1;
@@ -65 +65 @@
   bool
   PeerList::remPeerByAddr( ENetAddress addr )
-  { /* get an iterator */
-    std::list<ENetPeer *>::iterator i;
-
+  {
     /* loop through list elements */
-    for( i = peerlist.begin(); i != peerlist.end(); ++i )
-      if( !sub_compAddr((*i)->address, addr ) )
+    for( ENetPeer* peer : peerlist )
+      if( !sub_compAddr(peer->address, addr ) )
       { /* found this name, remove and quit */
-        this->peerlist.remove( *i );
+        this->peerlist.remove( peer );
         return true;
       }
@@ -82 +80 @@
   ENetPeer *
   PeerList::findPeerByAddr( ENetAddress addr )
-  { /* get an iterator */
-    std::list<ENetPeer *>::iterator i;
-
+  {
     /* loop through list elements */
-    for( i = peerlist.begin(); i != peerlist.end(); ++i )
-      if( !sub_compAddr((*i)->address, addr ) )
+    for( ENetPeer* peer : peerlist )
+      if( !sub_compAddr(peer->address, addr ) )
         /* found this name, remove and quit */
-        return *i;
+        return peer;
 
     /* not found */
-    return NULL;
+    return nullptr;
   }
 

code/branches/cpp11_v3/src/libraries/network/Server.cc

@@ -194 +194 @@
   void Server::printRTT()
   {
-//     for( ClientInformation* temp=ClientInformation::getBegin(); temp!=0; temp=temp->next() )
+//     for( ClientInformation* temp=ClientInformation::getBegin(); temp!=nullptr; temp=temp->next() )
 //       orxout(message) << "Round trip time to client with ID: " << temp->getID() << " is " << temp->getRTT() << " ms" << endl;
   }
@@ -232 +232 @@
   {
     std::vector<packet::Gamestate*> gamestates = GamestateManager::getGamestates();
-    std::vector<packet::Gamestate*>::iterator it;
-    for( it = gamestates.begin(); it != gamestates.end(); ++it )
+    for( packet::Gamestate* gamestate : gamestates )
     {
-      (*it)->send(static_cast<Host*>(this));
+      gamestate->send(static_cast<Host*>(this));
     }
     return true;
@@ -244 +243 @@
   {
 //     ClientInformation *temp = ClientInformation::getBegin();
-//     if( temp == NULL )
+//     if( temp == nullptr )
       //no client connected
     if( this->clientIDs_.size()==0 )
@@ -255 +254 @@
     }
 //     orxout(verbose, context::network) << "sending DeleteObjects" << endl;
-//     while(temp != NULL){
+//     while(temp != nullptr){
 //       if( !(temp->getSynched()) )
 //       {
@@ -434 +433 @@
       return true;
 
-    std::vector<uint32_t>::iterator it;
-    for( it=this->clientIDs_.begin(); it!=this->clientIDs_.end(); ++it )
-      if( *it == targetID )
+    for( uint32_t id : this->clientIDs_ )
+      if( id == targetID )
         return true;
 

code/branches/cpp11_v3/src/libraries/network/Server.h

@@ -61 +61 @@
     void open();
     void close();
-    void queuePacket(ENetPacket *packet, int clientID, uint8_t channelID);
-    virtual bool sendPacket( packet::Packet* packet ){ return packet->send( static_cast<Host*>(this) ); }
+    virtual void queuePacket(ENetPacket *packet, int clientID, uint8_t channelID) override;
+    virtual bool sendPacket( packet::Packet* packet ) override{ return packet->send( static_cast<Host*>(this) ); }
     void update(const Clock& time);
     unsigned int getRTT(unsigned int clientID);
-    virtual void printRTT();
+    virtual void printRTT() override;
     float getPacketLoss(unsigned int clientID);
     int getClientCount() { return this->clientIDs_.size();}
@@ -73 +73 @@
     void updateGamestate();
   private:
-    virtual bool isServer_(){return true;}
+    virtual bool isServer_() override{return true;}
     unsigned int playerID(){return 0;}
 
-    void addPeer(uint32_t peerID);
-    void removePeer(uint32_t peerID);
-    void processPacket(packet::Packet* packet);
+    virtual void addPeer(uint32_t peerID) override;
+    virtual void removePeer(uint32_t peerID) override;
+    virtual void processPacket(packet::Packet* packet) override;
 
     bool createClient(int clientID);
@@ -85 +85 @@
     bool sendObjectDeletes();
     bool isValidTarget(unsigned int targetID);
-    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
-    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
+    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID) override;
+    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID) override;
     void syncClassid(unsigned int clientID);
 

code/branches/cpp11_v3/src/libraries/network/ServerConnection.cc

@@ -73 +73 @@
     this->host_ = enet_host_create(this->bindAddress_, NETWORK_MAX_CONNECTIONS, NETWORK_CHANNEL_COUNT, 0, 0);
     
-    if ( this->host_ == NULL )
+    if ( this->host_ == nullptr )
     {
-        orxout(internal_error, context::network) << "ServerConnection: host_ == NULL" << endl;
+        orxout(internal_error, context::network) << "ServerConnection: host_ == nullptr" << endl;
         return false;
     }

code/branches/cpp11_v3/src/libraries/network/TrafficControl.cc

@@ -30 +30 @@
 
 #include <cassert>
-#include <boost/bind.hpp>
+#include <functional>
 
 #include "core/CoreIncludes.h"
@@ -38 +38 @@
 namespace orxonox {
 
-  static const unsigned int SCHED_PRIORITY_OFFSET = static_cast<unsigned int>(-1);
+  static constexpr unsigned int SCHED_PRIORITY_OFFSET = static_cast<unsigned int>(-1);
+  namespace arg = std::placeholders;
 
   objInfo::objInfo(uint32_t ID, uint32_t creatorID, int32_t curGsID, int32_t diffGsID, uint32_t size, unsigned int prioperm, unsigned int priosched)
@@ -64 +65 @@
 *Initializing protected members
 */
-    TrafficControl *TrafficControl::instance_=0;
+    TrafficControl *TrafficControl::instance_=nullptr;
 
     /**
@@ -72 +73 @@
     {
     RegisterObject(TrafficControl);
-      assert(instance_==0);
+      assert(instance_==nullptr);
       instance_=this;
     this->setConfigValues();
@@ -78 +79 @@
 
     /**
-    * @brief Destructor: resets the instance pointer to 0
+    * @brief Destructor: resets the instance pointer to nullptr
     */
     TrafficControl::~TrafficControl()
     {
-      instance_=0;
+      instance_=nullptr;
     }
 
@@ -148 +149 @@
     // shortcut for maps
     std::map<unsigned int, objInfo >& objectListPerm = clientListPerm_[clientID];
-    std::map<unsigned int, std::list<obj> >& objectListTemp = clientListTemp_[clientID];
+    std::map<unsigned int, std::list<obj>>& objectListTemp = clientListTemp_[clientID];
 
     for(itvec = objectListTemp[gamestateID].begin(); itvec != objectListTemp[gamestateID].end(); itvec++)
@@ -180 +181 @@
     void TrafficControl::insertinClientListPerm(unsigned int clientID, obj objinf)
     {
-      std::map<unsigned int,std::map<unsigned int, objInfo> >::iterator itperm;//iterator clientListPerm over clientIDs
+      std::map<unsigned int,std::map<unsigned int, objInfo>>::iterator itperm;//iterator clientListPerm over clientIDs
     unsigned int gsid=GAMESTATEID_INITIAL, gsdiff=currentGamestateID, prioperm=Synchronisable::getSynchronisable(objinf.objID)->getPriority(), priomom=0;
     clientListPerm_[clientID][objinf.objID] = objInfo(objinf.objID, objinf.objCreatorID,gsid,gsdiff, objinf.objSize,prioperm,priomom);
@@ -258 +259 @@
 
       //sort copied list according to priorities
-      // use boost bind here because we need to pass a memberfunction to stl sort
-//       sort( list.begin(), list.end(), boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
-      list.sort( boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
-
-//       list.sort(boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
+      // use std::bind here because we need to pass a memberfunction to stl sort
+//       sort( list.begin(), list.end(), std::bind(&TrafficControl::prioritySort, this, clientID, arg::_1, arg::_2) );
+      list.sort( std::bind(&TrafficControl::prioritySort, this, clientID, arg::_1, arg::_2) );
+
+//       list.sort(std::bind(&TrafficControl::prioritySort, this, clientID, arg::_1, arg::_2) );
 
       //now we check, that the creator of an object always exists on a client
@@ -275 +276 @@
       cut(list, targetSize);
       //now sort again after objDataOffset
-//       sort(list.begin(), list.end(), boost::bind(&TrafficControl::dataSort, this, _1, _2) );
-      list.sort( boost::bind(&TrafficControl::dataSort, this, _1, _2) );
+//       sort(list.begin(), list.end(), std::bind(&TrafficControl::dataSort, this, arg::_1, arg::_2) );
+      list.sort( std::bind(&TrafficControl::dataSort, this, arg::_1, arg::_2) );
 
       //diese Funktion updateClientList muss noch gemacht werden

code/branches/cpp11_v3/src/libraries/network/TrafficControl.h

@@ -82 +82 @@
     *permanent client list: contains client ids, object ids and objectInfos (in this order)
     */
-    std::map<unsigned int, std::map<unsigned int, objInfo > > clientListPerm_;
+    std::map<unsigned int, std::map<unsigned int, objInfo >> clientListPerm_;
     //has to be created with constructor and then needs to be updated by evaluateList().
 
@@ -88 +88 @@
     *temporary client list: contains client ids, gamestate ids and object ids (in this order)
     */
-    std::map<unsigned int, std::map<unsigned int, std::list<obj> > > clientListTemp_;
+    std::map<unsigned int, std::map<unsigned int, std::list<obj>>> clientListTemp_;
 
     /**updateReferenceList
@@ -109 +109 @@
 
     //ClientConnectionListener functions
-    virtual void clientConnected(unsigned int clientID){};
-    virtual void clientDisconnected(unsigned int clientID);
+    virtual void clientConnected(unsigned int clientID) override{};
+    virtual void clientDisconnected(unsigned int clientID) override;
 
 

code/branches/cpp11_v3/src/libraries/network/packet/Acknowledgement.h

@@ -46 +46 @@
   ~Acknowledgement();
 
-  inline unsigned int getSize() const;
-  virtual bool process(orxonox::Host* host);
+  virtual inline unsigned int getSize() const override;
+  virtual bool process(orxonox::Host* host) override;
 
   unsigned int getAckID();

code/branches/cpp11_v3/src/libraries/network/packet/Chat.h

@@ -49 +49 @@
 
   /* get size of packet */
-  inline unsigned int getSize() const;
+  virtual inline unsigned int getSize() const override;
 
   /* process chat message packet and remove it afterwards */
-  virtual bool process(orxonox::Host* host);
+  virtual bool process(orxonox::Host* host) override;
 
   /* Get the length of the message (not the full size of the packet) */

code/branches/cpp11_v3/src/libraries/network/packet/ClassID.cc

@@ -52 +52 @@
   uint32_t network_id;
   flags_ = flags_ | PACKET_FLAGS_CLASSID;
-  std::queue<std::pair<uint32_t, std::string> > tempQueue;
+  std::queue<std::pair<uint32_t, std::string>> tempQueue;
 
   //calculate total needed size (for all strings and integers)
-  std::map<std::string, Identifier*>::const_iterator it = IdentifierManager::getInstance().getIdentifierByStringMap().begin();
-  for(;it != IdentifierManager::getInstance().getIdentifierByStringMap().end();++it){
-    id = it->second;
-    if(id == NULL || !id->hasFactory())
+  for(const auto& mapEntry : IdentifierManager::getInstance().getIdentifierByStringMap()){
+    id = mapEntry.second;
+    if(id == nullptr || !id->hasFactory())
       continue;
     const std::string& classname = id->getName();
@@ -144 +143 @@
     id=ClassByString( std::string((const char*)classname) );
     orxout(internal_info, context::packets) << "processing classid: " << networkID << " name: " << classname << " id: " << id << endl;
-    if(id==NULL){
+    if(id==nullptr){
       orxout(user_error, context::packets) << "Received a bad classname" << endl;
       abort();

code/branches/cpp11_v3/src/libraries/network/packet/ClassID.h

@@ -47 +47 @@
   ~ClassID();
 
-  uint32_t getSize() const;
-  virtual bool process(orxonox::Host* host);
+  virtual uint32_t getSize() const override;
+  virtual bool process(orxonox::Host* host) override;
 
 private:

code/branches/cpp11_v3/src/libraries/network/packet/DeleteObjects.h

@@ -48 +48 @@
   bool fetchIDs();
 
-  inline unsigned int getSize() const;
-  virtual bool process(orxonox::Host* host);
+  virtual inline unsigned int getSize() const override;
+  virtual bool process(orxonox::Host* host) override;
 
 private:

code/branches/cpp11_v3/src/libraries/network/packet/FunctionCalls.h

@@ -52 +52 @@
   ~FunctionCalls();
 
-  inline unsigned int getSize() const
+  virtual inline unsigned int getSize() const override
     { assert(!this->isDataENetAllocated()); return currentSize_; }
-  virtual bool process(orxonox::Host* host);
+  virtual bool process(orxonox::Host* host) override;
 
   void addCall( uint32_t networkID, uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5);
-  virtual bool send(orxonox::Host* host);
+  virtual bool send(orxonox::Host* host) override;
 private:
   std::queue<orxonox::FunctionCall> functionCalls_;

code/branches/cpp11_v3/src/libraries/network/packet/FunctionIDs.cc

@@ -53 +53 @@
   uint32_t networkID;
   flags_ = flags_ | PACKET_FLAGS_FUNCTIONIDS;
-  std::queue<std::pair<uint32_t, std::string> > tempQueue;
+  std::queue<std::pair<uint32_t, std::string>> tempQueue;
 
   //calculate total needed size (for all strings and integers)

code/branches/cpp11_v3/src/libraries/network/packet/FunctionIDs.h

@@ -47 +47 @@
   ~FunctionIDs();
 
-  virtual uint32_t getSize() const;
-  virtual bool process(orxonox::Host* host);
+  virtual uint32_t getSize() const override;
+  virtual bool process(orxonox::Host* host) override;
 
 private:

code/branches/cpp11_v3/src/libraries/network/packet/Gamestate.cc

@@ -106 +106 @@
 {
   uint32_t tempsize=0, currentsize=0;
-  assert(data_==0);
+  assert(data_==nullptr);
   uint32_t size = calcGamestateSize(id, mode);
 
@@ -126 +126 @@
   mem += GamestateHeader::getSize();
   ObjectList<Synchronisable>::iterator it;
-  for(it = ObjectList<Synchronisable>::begin(); it; ++it)
+  for(it = ObjectList<Synchronisable>().begin(); it; ++it)
   {
 
@@ -133 +133 @@
     tempsize = it->getData(mem, this->sizes_, id, mode);
     if ( tempsize != 0 )
-      dataVector_.push_back( obj(it->getObjectID(), it->getContextID(), tempsize, mem-data_) );
+      dataVector_.emplace_back(it->getObjectID(), it->getContextID(), tempsize, mem-data_);
 
 #ifndef NDEBUG
@@ -213 +213 @@
   {
     std::list<uint32_t> v1;
-    ObjectList<Synchronisable>::iterator it;
-    for (it = ObjectList<Synchronisable>::begin(); it != ObjectList<Synchronisable>::end(); ++it)
-    {
-      if (it->getObjectID() == OBJECTID_UNKNOWN)
-      {
-        if (it->objectMode_ != 0x0)
+    for (Synchronisable* synchronisable : ObjectList<Synchronisable>())
+    {
+      if (synchronisable->getObjectID() == OBJECTID_UNKNOWN)
+      {
+        if (synchronisable->objectMode_ != 0x0)
         {
           orxout(user_error, context::packets) << "Found object with OBJECTID_UNKNOWN on the client with objectMode != 0x0!" << endl;
           orxout(user_error, context::packets) << "Possible reason for this error: Client created a synchronized object without the Server's approval." << endl;
-          orxout(user_error, context::packets) << "Objects class: " << it->getIdentifier()->getName() << endl;
+          orxout(user_error, context::packets) << "Objects class: " << synchronisable->getIdentifier()->getName() << endl;
           assert(false);
         }
@@ -228 +227 @@
       else
       {
-        std::list<uint32_t>::iterator it2;
-        for (it2 = v1.begin(); it2 != v1.end(); ++it2)
+        for (uint32_t id : v1)
         {
-          if (it->getObjectID() == *it2)
+          if (synchronisable->getObjectID() == id)
           {
             orxout(user_error, context::packets) << "Found duplicate objectIDs on the client!" << endl
@@ -239 +237 @@
           }
         }
-        v1.push_back(it->getObjectID());
+        v1.push_back(synchronisable->getObjectID());
       }
     }
@@ -608 +606 @@
 
   if(dest_length==0)
-    return NULL;
+    return nullptr;
 
   uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+GamestateHeader::getSize()];
@@ -645 +643 @@
 
   if(dest_length==0)
-    return NULL;
+    return nullptr;
 
   uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+GamestateHeader::getSize()];
@@ -762 +760 @@
   uint32_t size = 0;
   uint32_t nrOfVariables = 0;
-    // get the start of the Synchronisable list
-  ObjectList<Synchronisable>::iterator it;
     // get total size of gamestate
-  for(it = ObjectList<Synchronisable>::begin(); it; ++it){
-    size+=it->getSize(id, mode); // size of the actual data of the synchronisable
-    nrOfVariables += it->getNrOfVariables();
+  for(Synchronisable* synchronisable : ObjectList<Synchronisable>()){
+    size+=synchronisable->getSize(id, mode); // size of the actual data of the synchronisable
+    nrOfVariables += synchronisable->getNrOfVariables();
   }
 //   orxout() << "allocating " << nrOfVariables << " ints" << endl;

code/branches/cpp11_v3/src/libraries/network/packet/Gamestate.h

@@ -48 +48 @@
 {
     
-static const uint8_t GAMESTATE_MODE_SERVER = 0x1;
-static const uint8_t GAMESTATE_MODE_CLIENT = 0x2;
+static constexpr uint8_t GAMESTATE_MODE_SERVER = 0x1;
+static constexpr uint8_t GAMESTATE_MODE_CLIENT = 0x2;
 
 class _NetworkExport GamestateHeader
 {
   public:
-    GamestateHeader(){ data_=0; }
+    GamestateHeader(){ data_=nullptr; }
     GamestateHeader(uint8_t* data)
       { assert(data); data_ = data; *(uint32_t*)data_ = Type::Gamestate; }
@@ -138 +138 @@
 //     void rawDiff( uint8_t* newdata, uint8_t* data, uint8_t* basedata, uint32_t datalength, uint32_t baselength);
 //     inline uint32_t findObject( const SynchronisableHeader& header, uint8_t* mem, uint32_t dataLength, uint32_t startPosition = 0 );
-    virtual uint32_t getSize() const;
-    virtual bool process(orxonox::Host* host);
+    virtual uint32_t getSize() const override;
+    virtual bool process(orxonox::Host* host) override;
     uint32_t calcGamestateSize(uint32_t id, uint8_t mode=0x0);
 //     inline void diffObject( uint8_t*& newData, uint8_t*& origData, uint8_t*& baseData, SynchronisableHeader& objectHeader, std::vector<uint32_t>::iterator& sizes );

code/branches/cpp11_v3/src/libraries/network/packet/Packet.cc

@@ -34 +34 @@
 #define WIN32_LEAN_AND_MEAN
 #include <enet/enet.h>
-#include <boost/static_assert.hpp>
 #include <boost/thread/mutex.hpp>
 
@@ -54 +53 @@
 
 // Make sure we assume the right values
-BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::Reliable)    == static_cast<int>(ENET_PACKET_FLAG_RELIABLE));
-BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::Unsequenced) == static_cast<int>(ENET_PACKET_FLAG_UNSEQUENCED));
-BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::NoAllocate)  == static_cast<int>(ENET_PACKET_FLAG_NO_ALLOCATE));
+static_assert(static_cast<int>(PacketFlag::Reliable)    == static_cast<int>(ENET_PACKET_FLAG_RELIABLE),    "check enum");
+static_assert(static_cast<int>(PacketFlag::Unsequenced) == static_cast<int>(ENET_PACKET_FLAG_UNSEQUENCED), "check enum");
+static_assert(static_cast<int>(PacketFlag::NoAllocate)  == static_cast<int>(ENET_PACKET_FLAG_NO_ALLOCATE), "check enum");
 
 #define PACKET_FLAG_DEFAULT PacketFlag::NoAllocate
@@ -69 +68 @@
   packetDirection_ = Direction::Outgoing;
   peerID_=0;
-  data_=0;
-  enetPacket_=0;
+  data_=nullptr;
+  enetPacket_=nullptr;
   bDataENetAllocated_ = false;
 }
@@ -80 +79 @@
   peerID_=peerID;
   data_=data;
-  enetPacket_=0;
+  enetPacket_=nullptr;
   bDataENetAllocated_ = false;
 }
@@ -95 +94 @@
     memcpy(data_, p.data_, p.getSize());
   }else
-    data_=0;
+    data_=nullptr;
   bDataENetAllocated_ = p.bDataENetAllocated_;
 }
@@ -122 +121 @@
   // Destroy the ENetPacket if necessary.
   // Note: For the case ENet used the callback to destroy the packet, we have already set
-  // enetPacket_ to NULL to avoid destroying it again.
+  // enetPacket_ to nullptr to avoid destroying it again.
   if (this->enetPacket_)
   {
@@ -175 +174 @@
 #endif
 //  ENetPacket *temp = enetPacket_;
-//  enetPacket_ = 0; // otherwise we have a double free because enet already handles the deallocation of the packet
+//  enetPacket_ = nullptr; // otherwise we have a double free because enet already handles the deallocation of the packet
   if( this->flags_ & PacketFlag::Reliable )
     host->addPacket( enetPacket_, peerID_, NETWORK_CHANNEL_DEFAULT);
@@ -191 +190 @@
 //   if( peerID==static_cast<unsigned int>(-2))
 //     peerID = NETWORK_PEER_ID_SERVER;
-  Packet *p = 0;
+  Packet *p = nullptr;
 //   orxout(verbose_ultra, context::packets) << "packet type: " << *(Type::Value *)&data[_PACKETID] << endl;
   switch( *(Type::Value *)(data + _PACKETID) )
@@ -251 +250 @@
   assert(it != packetMap_.end());
   // Make sure we don't delete it again in the destructor
-  it->second->enetPacket_ = 0;
+  it->second->enetPacket_ = nullptr;
   delete it->second;
   packetMap_.erase(it);

code/branches/cpp11_v3/src/libraries/network/packet/ServerInformation.cc

@@ -87 +87 @@
   } // namespace packet
 
-  std::ostream& operator<<(std::ostream& out, const ENetAddress& address)
-  {
-      char addr[64];
-      if (!enet_address_get_host_ip(&address, addr, 64))
-          out << addr;
-      return out;
-  }
 } // namespace orxonox
+
+std::ostream& operator<<(std::ostream& out, const ENetAddress& address)
+{
+    char addr[64];
+    if (!enet_address_get_host_ip(&address, addr, 64))
+        out << addr;
+    return out;
+}

code/branches/cpp11_v3/src/libraries/network/packet/ServerInformation.h

@@ -50 +50 @@
         void          send( ENetPeer* peer );
         void          setServerName(std::string name) { this->serverName_ = name; }
-        std::string   getServerName() { return this->serverName_; }
+        std::string   getServerName() const { return this->serverName_; }
         void          setServerIP( std::string IP ) { this->serverIP_ = IP; }
-        std::string   getServerIP() { return this->serverIP_; }
+        std::string   getServerIP() const { return this->serverIP_; }
         void          setClientNumber( int clientNumber ) { this->clientNumber_ = clientNumber; }
-        int           getClientNumber() { return this->clientNumber_; }
-        uint32_t      getServerRTT() { return this->serverRTT_; }
+        int           getClientNumber() const { return this->clientNumber_; }
+        uint32_t      getServerRTT() const { return this->serverRTT_; }
 
       private:
@@ -66 +66 @@
   }
 
-  _NetworkExport std::ostream& operator<<(std::ostream& out, const ENetAddress& address);
 }
 
+_NetworkExport std::ostream& operator<<(std::ostream& out, const ENetAddress& address);
+
 #endif // SERVERINFORMATION_H

code/branches/cpp11_v3/src/libraries/network/packet/Welcome.h

@@ -45 +45 @@
   virtual ~Welcome();
 
-  uint8_t *getData();
-  inline unsigned int getSize() const;
-  virtual bool process(orxonox::Host* host);
+  virtual uint8_t *getData() override;
+  virtual inline unsigned int getSize() const override;
+  virtual bool process(orxonox::Host* host) override;
 
 private:

code/branches/cpp11_v3/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/branches/cpp11_v3/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/branches/cpp11_v3/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/branches/cpp11_v3/src/libraries/network/synchronisable/Synchronisable.h

@@ -171 +171 @@
   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);
 
@@ -242 +242 @@
     SynchronisableVariableBase* sv;
     if (bidirectional)
-      sv = new SynchronisableVariableBidirectional<std::set<T> >(variable, mode, cb);
+      sv = new SynchronisableVariableBidirectional<std::set<T>>(variable, mode, cb);
     else
-      sv = new SynchronisableVariable<std::set<T> >(variable, mode, cb);
+      sv = new SynchronisableVariable<std::set<T>>(variable, mode, cb);
     syncList_.push_back(sv);
     stringList_.push_back(sv);
@@ -250 +250 @@
 
   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/branches/cpp11_v3/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();