Use lambdas instead of std::bind (#1200)

src/framework/core/application.cpp

@@ -46,7 +46,9 @@ void exitSignalHandler(int sig)
         case SIGINT:
             if(!signaled && !g_app.isStopping() && !g_app.isTerminated()) {
                 signaled = true;
-                g_dispatcher.addEvent(std::bind(&Application::close, &g_app));
+                g_dispatcher.addEvent([] () {
+                    g_app.close();
+                });
             }
             break;
     }

src/framework/core/asyncdispatcher.cpp

@@ -38,7 +38,9 @@ void AsyncDispatcher::terminate()
 void AsyncDispatcher::spawn_thread()
 {
     m_running = true;
-    m_threads.emplace_back(std::bind(&AsyncDispatcher::exec_loop, this));
+    m_threads.emplace_back([this] () {
+        exec_loop();
+    });
 }
 
 void AsyncDispatcher::stop()

src/framework/core/graphicalapplication.cpp

@@ -45,9 +45,15 @@ void GraphicalApplication::init(std::vector<std::string>& args)
     // setup platform window
     g_window.init();
     g_window.hide();
-    g_window.setOnResize(std::bind(&GraphicalApplication::resize, this, std::placeholders::_1));
+    g_window.setOnResize([this] (auto size) {
-    g_window.setOnInputEvent(std::bind(&GraphicalApplication::inputEvent, this, std::placeholders::_1));
+        resize(size);
-    g_window.setOnClose(std::bind(&GraphicalApplication::close, this));
+    });
+    g_window.setOnInputEvent([this] (const auto &event) {
+        inputEvent(event);
+    });
+    g_window.setOnClose([this] () {
+        close();
+    });
 
     g_mouse.init();
 

src/framework/net/connection.cpp

@@ -98,20 +98,28 @@ void Connection::connect(const std::string& host, uint16 port, const std::functi
     m_connectCallback = connectCallback;
 
     asio::ip::tcp::resolver::query query(host, stdext::unsafe_cast<std::string>(port));
-    m_resolver.async_resolve(query, std::bind(&Connection::onResolve, asConnection(), std::placeholders::_1, std::placeholders::_2));
+    m_resolver.async_resolve(query, [connection = asConnection()] (auto error, auto iterator) {
+        connection->onResolve(error, iterator);
+    });
 
     m_readTimer.cancel();
     m_readTimer.expires_from_now(boost::posix_time::seconds(static_cast<uint32>(READ_TIMEOUT)));
-    m_readTimer.async_wait(std::bind(&Connection::onTimeout, asConnection(), std::placeholders::_1));
+    m_readTimer.async_wait([connection = asConnection()] (auto error) {
+        connection->onTimeout(error);
+    });
 }
 
 void Connection::internal_connect(asio::ip::basic_resolver<asio::ip::tcp>::iterator endpointIterator)
 {
-    m_socket.async_connect(*endpointIterator, std::bind(&Connection::onConnect, asConnection(), std::placeholders::_1));
+    m_socket.async_connect(*endpointIterator, [connection = asConnection()] (auto error) {
+        connection->onConnect(error);
+    });
 
     m_readTimer.cancel();
     m_readTimer.expires_from_now(boost::posix_time::seconds(static_cast<uint32>(READ_TIMEOUT)));
-    m_readTimer.async_wait(std::bind(&Connection::onTimeout, asConnection(), std::placeholders::_1));
+    m_readTimer.async_wait([connection = asConnection()] (auto error) {
+        connection->onTimeout(error);
+    });
 }
 
 void Connection::write(uint8* buffer, size_t size)
@@ -129,7 +137,9 @@ void Connection::write(uint8* buffer, size_t size)
 
         m_delayedWriteTimer.cancel();
         m_delayedWriteTimer.expires_from_now(boost::posix_time::milliseconds(0));
-        m_delayedWriteTimer.async_wait(std::bind(&Connection::onCanWrite, asConnection(), std::placeholders::_1));
+        m_delayedWriteTimer.async_wait([connection = asConnection()] (auto error) {
+            connection->onCanWrite(error);
+        });
     }
 
     std::ostream os(m_outputStream.get());
@@ -145,13 +155,15 @@ void Connection::internal_write()
     std::shared_ptr<asio::streambuf> outputStream = m_outputStream;
     m_outputStream = nullptr;
 
-    asio::async_write(m_socket,
+    asio::async_write(m_socket, *outputStream, [connection = asConnection(), outputStream] (auto error, auto size) {
-                      *outputStream,
+        connection->onWrite(error, size, outputStream);
-                      std::bind(&Connection::onWrite, asConnection(), std::placeholders::_1, std::placeholders::_2, outputStream));
+    });
 
     m_writeTimer.cancel();
     m_writeTimer.expires_from_now(boost::posix_time::seconds(static_cast<uint32>(WRITE_TIMEOUT)));
-    m_writeTimer.async_wait(std::bind(&Connection::onTimeout, asConnection(), std::placeholders::_1));
+    m_writeTimer.async_wait([connection = asConnection()] (auto error) {
+        connection->onTimeout(error);
+    });
 }
 
 void Connection::read(uint16 bytes, const RecvCallback& callback)
@@ -161,13 +173,15 @@ void Connection::read(uint16 bytes, const RecvCallback& callback)
 
     m_recvCallback = callback;
 
-    asio::async_read(m_socket,
+    asio::async_read(m_socket, asio::mutable_buffer(m_inputStream.prepare(bytes)), [connection = asConnection()] (auto error, auto size) {
-                     asio::mutable_buffer(m_inputStream.prepare(bytes)),
+        connection->onRecv(error, size);
-                     std::bind(&Connection::onRecv, asConnection(), std::placeholders::_1, std::placeholders::_2));
+    });
 
     m_readTimer.cancel();
     m_readTimer.expires_from_now(boost::posix_time::seconds(static_cast<uint32>(READ_TIMEOUT)));
-    m_readTimer.async_wait(std::bind(&Connection::onTimeout, asConnection(), std::placeholders::_1));
+    m_readTimer.async_wait([connection = asConnection()] (auto error) {
+        connection->onTimeout(error);
+    });
 }
 
 void Connection::read_until(const std::string& what, const RecvCallback& callback)
@@ -177,14 +191,15 @@ void Connection::read_until(const std::string& what, const RecvCallback& callbac
 
     m_recvCallback = callback;
 
-    asio::async_read_until(m_socket,
+    asio::async_read_until(m_socket, m_inputStream, what, [connection = asConnection()] (auto error, auto size) {
-                           m_inputStream,
+        connection->onRecv(error, size);
-                           what,
+    });
-                           std::bind(&Connection::onRecv, asConnection(), std::placeholders::_1, std::placeholders::_2));
 
     m_readTimer.cancel();
     m_readTimer.expires_from_now(boost::posix_time::seconds(static_cast<uint32>(READ_TIMEOUT)));
-    m_readTimer.async_wait(std::bind(&Connection::onTimeout, asConnection(), std::placeholders::_1));
+    m_readTimer.async_wait([connection = asConnection()] (auto error) {
+        connection->onTimeout(error);
+    });
 }
 
 void Connection::read_some(const RecvCallback& callback)
@@ -194,12 +209,15 @@ void Connection::read_some(const RecvCallback& callback)
 
     m_recvCallback = callback;
 
-    m_socket.async_read_some(asio::mutable_buffer(m_inputStream.prepare(RECV_BUFFER_SIZE)),
+    m_socket.async_read_some(asio::mutable_buffer(m_inputStream.prepare(RECV_BUFFER_SIZE)), [connection = asConnection()] (auto buffer, auto size) {
-                             std::bind(&Connection::onRecv, asConnection(), std::placeholders::_1, std::placeholders::_2));
+        connection->onRecv(buffer, size);
+    });
 
     m_readTimer.cancel();
     m_readTimer.expires_from_now(boost::posix_time::seconds(static_cast<uint32>(READ_TIMEOUT)));
-    m_readTimer.async_wait(std::bind(&Connection::onTimeout, asConnection(), std::placeholders::_1));
+    m_readTimer.async_wait([connection = asConnection()] (auto error) {
+        connection->onTimeout(error);
+    });
 }
 
 void Connection::onResolve(const boost::system::error_code& error, asio::ip::basic_resolver<asio::ip::tcp>::iterator endpointIterator)

src/framework/net/protocol.cpp

@@ -43,8 +43,12 @@ Protocol::~Protocol()
 void Protocol::connect(const std::string& host, uint16 port)
 {
     m_connection = ConnectionPtr(new Connection);
-    m_connection->setErrorCallback(std::bind(&Protocol::onError, asProtocol(), std::placeholders::_1));
+    m_connection->setErrorCallback([proto = asProtocol()] (auto error) {
-    m_connection->connect(host, port, std::bind(&Protocol::onConnect, asProtocol()));
+        proto->onError(error);
+    });
+    m_connection->connect(host, port, [proto = asProtocol()] () {
+        proto->onConnect();
+    });
 }
 
 void Protocol::disconnect()
@@ -104,7 +108,9 @@ void Protocol::recv()
 
     // read the first 2 bytes which contain the message size
     if(m_connection)
-        m_connection->read(2, std::bind(&Protocol::internalRecvHeader, asProtocol(), std::placeholders::_1,  std::placeholders::_2));
+        m_connection->read(2, [proto = asProtocol()] (auto buffer, auto size) {
+            proto->internalRecvHeader(buffer, size);
+        });
 }
 
 void Protocol::internalRecvHeader(uint8* buffer, uint16 size)
@@ -115,7 +121,9 @@ void Protocol::internalRecvHeader(uint8* buffer, uint16 size)
 
     // read remaining message data
     if(m_connection)
-        m_connection->read(remainingSize, std::bind(&Protocol::internalRecvData, asProtocol(), std::placeholders::_1,  std::placeholders::_2));
+        m_connection->read(remainingSize, [proto = asProtocol()] (auto buffer, auto size) {
+            proto->internalRecvData(buffer, size);
+        });
 }
 
 void Protocol::internalRecvData(uint8* buffer, uint16 size)

src/framework/net/protocolhttp.cpp

@@ -39,8 +39,12 @@ ProtocolHttp::~ProtocolHttp()
 void ProtocolHttp::connect(const std::string& host, uint16 port)
 {
     m_connection = ConnectionPtr(new Connection);
-    m_connection->setErrorCallback(std::bind(&ProtocolHttp::onError, asProtocolHttp(), std::placeholders::_1));
+    m_connection->setErrorCallback([proto = asProtocolHttp()] (auto error) {
-    m_connection->connect(host, port, std::bind(&ProtocolHttp::onConnect, asProtocolHttp()));
+        proto->onError(error);
+    });
+    m_connection->connect(host, port, [proto = asProtocolHttp()] () {
+        proto->onConnect();
+    });
 }
 
 void ProtocolHttp::disconnect()
@@ -60,7 +64,9 @@ void ProtocolHttp::send(const std::string& message)
 void ProtocolHttp::recv()
 {
     if(m_connection)
-        m_connection->read_until("\r\n\r\n", std::bind(&ProtocolHttp::onRecv, asProtocolHttp(), std::placeholders::_1,  std::placeholders::_2));
+        m_connection->read_until("\r\n\r\n", [proto = asProtocolHttp()] (auto buffer, auto size) {
+            proto->onRecv(buffer, size);
+        });
 }
 
 void ProtocolHttp::onConnect()