Changeset 10771 for code/branches/cpp11_v2/src/libraries/core/Game.cc

Timestamp:

Nov 7, 2015, 5:24:58 PM (9 years ago)

Author:

landauf

Message:

using std::shared_ptr instead of boost::shared_ptr (same for weak_ptr)

File:

• code/branches/cpp11_v2/src/libraries/core/Game.cc (modified) (18 diffs)

code/branches/cpp11_v2/src/libraries/core/Game.cc

@@ -36 +36 @@
 
 #include <exception>
-#include <boost/weak_ptr.hpp>
 #include <loki/ScopeGuard.h>
 
@@ -72 +71 @@
     {
         std::string name_;
-        weak_ptr<GameStateTreeNode> parent_;
-        std::vector<shared_ptr<GameStateTreeNode>> children_;
+        std::weak_ptr<GameStateTreeNode> parent_;
+        std::vector<std::shared_ptr<GameStateTreeNode>> children_;
     };
 
@@ -124 +123 @@
 
         // The empty root state is ALWAYS loaded!
-        this->rootStateNode_ = shared_ptr<GameStateTreeNode>(new GameStateTreeNode());
+        this->rootStateNode_ = std::shared_ptr<GameStateTreeNode>(new GameStateTreeNode());
         this->rootStateNode_->name_ = "emptyRootGameState";
         this->loadedTopStateNode_ = this->rootStateNode_;
@@ -137 +136 @@
 
         assert(loadedStates_.size() <= 1); // Just empty root GameState
-        // Destroy all GameStates (shared_ptrs take care of actual destruction)
+        // Destroy all GameStates (std::shared_ptrs take care of actual destruction)
         constructedStates_.clear();
 
@@ -235 +234 @@
         while (this->requestedStateNodes_.size() > 0)
         {
-            shared_ptr<GameStateTreeNode> requestedStateNode = this->requestedStateNodes_.front();
+            std::shared_ptr<GameStateTreeNode> requestedStateNode = this->requestedStateNodes_.front();
             assert(this->loadedTopStateNode_);
             if (!this->loadedTopStateNode_->parent_.expired() && requestedStateNode == this->loadedTopStateNode_->parent_.lock())
@@ -281 +280 @@
                 orxout(user_error) << "This should really never happen!" << endl;
                 orxout(user_error) << "Unloading all GameStates depending on the one that crashed." << endl;
-                shared_ptr<GameStateTreeNode> current = this->loadedTopStateNode_;
+                std::shared_ptr<GameStateTreeNode> current = this->loadedTopStateNode_;
                 while (current->name_ != (*it)->getName() && current)
                     current = current->parent_.lock();
@@ -372 +371 @@
         }
 
-        shared_ptr<GameStateTreeNode> lastRequestedNode;
+        std::shared_ptr<GameStateTreeNode> lastRequestedNode;
         if (this->requestedStateNodes_.empty())
             lastRequestedNode = this->loadedTopStateNode_;
@@ -384 +383 @@
 
         // Check children first
-        std::vector<shared_ptr<GameStateTreeNode>> requestedNodes;
+        std::vector<std::shared_ptr<GameStateTreeNode>> requestedNodes;
         for (unsigned int i = 0; i < lastRequestedNode->children_.size(); ++i)
         {
@@ -397 +396 @@
         {
             // Check parent and all its grand parents
-            shared_ptr<GameStateTreeNode> currentNode = lastRequestedNode;
+            std::shared_ptr<GameStateTreeNode> currentNode = lastRequestedNode;
             while (currentNode != nullptr)
             {
@@ -424 +423 @@
     void Game::popState()
     {
-        shared_ptr<GameStateTreeNode> lastRequestedNode;
+        std::shared_ptr<GameStateTreeNode> lastRequestedNode;
         if (this->requestedStateNodes_.empty())
             lastRequestedNode = this->loadedTopStateNode_;
@@ -435 +434 @@
     }
 
-    shared_ptr<GameState> Game::getState(const std::string& name)
+    std::shared_ptr<GameState> Game::getState(const std::string& name)
     {
         GameStateMap::const_iterator it = constructedStates_.find(name);
@@ -447 +446 @@
             else
                 orxout(internal_error) << "Could not find GameState '" << name << "'." << endl;
-            return shared_ptr<GameState>();
+            return std::shared_ptr<GameState>();
         }
     }
@@ -479 +478 @@
     /*** Internal ***/
 
-    void Game::parseStates(std::vector<std::pair<std::string, int>>::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode)
+    void Game::parseStates(std::vector<std::pair<std::string, int>>::const_iterator& it, std::shared_ptr<GameStateTreeNode> currentNode)
     {
         SubString tokens(it->first, ",");
@@ -491 +490 @@
             if (tokens[i] == this->rootStateNode_->name_)
                 ThrowException(GameState, "You shouldn't use 'emptyRootGameState' in the hierarchy...");
-            shared_ptr<GameStateTreeNode> node(new GameStateTreeNode());
+            std::shared_ptr<GameStateTreeNode> node(new GameStateTreeNode());
             node->name_ = tokens[i];
             node->parent_ = currentNode;
@@ -527 +526 @@
                 {
                     // Game state loading failure is serious --> don't catch
-                    shared_ptr<GameState> gameState = GameStateFactory::fabricate(it->second);
+                    std::shared_ptr<GameState> gameState = GameStateFactory::fabricate(it->second);
                     if (!constructedStates_.insert(std::make_pair(
                         it->second.stateName, gameState)).second)
@@ -582 +581 @@
             graphicsUnloader.Dismiss();
 
-        shared_ptr<GameState> state = this->getState(name);
+        std::shared_ptr<GameState> state = this->getState(name);
         state->activateInternal();
         if (!this->loadedStates_.empty())
@@ -599 +598 @@
         try
         {
-            shared_ptr<GameState> state = this->getState(name);
+            std::shared_ptr<GameState> state = this->getState(name);
             state->activity_.topState = false;
             this->loadedStates_.pop_back();
@@ -620 +619 @@
     }
 
-    /*static*/ std::map<std::string, shared_ptr<Game::GameStateFactory>>& Game::GameStateFactory::getFactories()
-    {
-        static std::map<std::string, shared_ptr<GameStateFactory>> factories;
+    /*static*/ std::map<std::string, std::shared_ptr<Game::GameStateFactory>>& Game::GameStateFactory::getFactories()
+    {
+        static std::map<std::string, std::shared_ptr<GameStateFactory>> factories;
         return factories;
     }
 
-    /*static*/ shared_ptr<GameState> Game::GameStateFactory::fabricate(const GameStateInfo& info)
-    {
-        std::map<std::string, shared_ptr<Game::GameStateFactory>>::const_iterator it = getFactories().find(info.className);
+    /*static*/ std::shared_ptr<GameState> Game::GameStateFactory::fabricate(const GameStateInfo& info)
+    {
+        std::map<std::string, std::shared_ptr<Game::GameStateFactory>>::const_iterator it = getFactories().find(info.className);
         assert(it != getFactories().end());
         return it->second->fabricateInternal(info);