Refactored to use range based for instead of BOOST_FOREACH

[casparcg] / protocol / util / AsyncEventServer.cpp

diff --git a/protocol/util/AsyncEventServer.cpp b/protocol/util/AsyncEventServer.cpp
index d7225d5b148d82b78e8d6dfabcb50c2e2ab65fd6..746fa3325ad2617453ed5c15691ea00e27430ad4 100644 (file)
--- a/protocol/util/AsyncEventServer.cpp
+++ b/protocol/util/AsyncEventServer.cpp
@@ -28,6 +28,7 @@
 #include <string>
 #include <set>
 #include <memory>
+#include <functional>
 
 #include <boost/asio.hpp>
 #include <boost/thread.hpp>
@@ -66,34 +67,50 @@ class connection : public spl::enable_shared_from_this<connection>
        {
                std::weak_ptr<connection> connection_;
        public:
-               explicit connection_holder(std::weak_ptr<connection> conn) : connection_(conn)
+               explicit connection_holder(std::weak_ptr<connection> conn) : connection_(std::move(conn))
                {}
 
                virtual void send(std::basic_string<char>&& data)
                {
                        auto conn = connection_.lock();
-                       conn->send(std::move(data));
+
+                       if (conn)
+                               conn->send(std::move(data));
                }
+
                virtual void disconnect()
                {
                        auto conn = connection_.lock();
-                       conn->disconnect();
+
+                       if (conn)
+                               conn->disconnect();
                }
+
                virtual std::wstring print() const
                {
                        auto conn = connection_.lock();
-                       return conn->print();
+
+                       if (conn)
+                               return conn->print();
+                       else
+                               return L"[destroyed-connection]";
                }
 
                virtual void add_lifecycle_bound_object(const std::wstring& key, const std::shared_ptr<void>& lifecycle_bound)
                {
                        auto conn = connection_.lock();
-                       return conn->add_lifecycle_bound_object(key, lifecycle_bound);
+
+                       if (conn)
+                               return conn->add_lifecycle_bound_object(key, lifecycle_bound);
                }
                virtual std::shared_ptr<void> remove_lifecycle_bound_object(const std::wstring& key)
                {
                        auto conn = connection_.lock();
-                       return conn->remove_lifecycle_bound_object(key);
+
+                       if (conn)
+                               return conn->remove_lifecycle_bound_object(key);
+                       else
+                               return std::shared_ptr<void>();
                }
        };
 
@@ -126,7 +143,7 @@ public:
                service_.dispatch([=] { stop(); });
        }
 
-       void add_lifecycle_bound_object(const std::wstring& key, const std::shared_ptr<void> lifecycle_bound)
+       void add_lifecycle_bound_object(const std::wstring& key, const std::shared_ptr<void>& lifecycle_bound)
        {
                //thread-safe tbb_concurrent_hash_map
                lifecycle_bound_objects_.insert(std::pair<std::wstring, std::shared_ptr<void>>(key, lifecycle_bound));
@@ -268,7 +285,7 @@ struct AsyncEventServer::implementation
        implementation(const protocol_strategy_factory<char>::ptr& protocol, unsigned short port)
                : acceptor_(service_, tcp::endpoint(tcp::v4(), port))
                , protocol_factory_(protocol)
-               , thread_(std::bind(&boost::asio::io_service::run, &service_))
+               , thread_([&] { service_.run(); })
        {
                start_accept();
        }
@@ -287,7 +304,7 @@ struct AsyncEventServer::implementation
                service_.post([=]
                {
                        auto connections = *connection_set_;
-                       BOOST_FOREACH(auto& connection, connections)
+                       for (auto& connection : connections)
                                connection->stop();                             
                });
 
@@ -310,7 +327,7 @@ struct AsyncEventServer::implementation
                        auto conn = connection::create(socket, protocol_factory_, connection_set_);
                        connection_set_->insert(conn);
 
-                       BOOST_FOREACH(auto& lifecycle_factory, lifecycle_factories_)
+                       for (auto& lifecycle_factory : lifecycle_factories_)
                        {
                                auto lifecycle_bound = lifecycle_factory(conn->ipv4_address());
                                conn->add_lifecycle_bound_object(lifecycle_bound.first, lifecycle_bound.second);