Convert trivial usages of Boost.Bind to lambda expressions

Author: tstenner

src/data_receiver.cpp

@@ -63,6 +63,7 @@ data_receiver::~data_receiver() {
 void data_receiver::open_stream(double timeout) {
 	closing_stream_ = false;
 	lslboost::unique_lock<lslboost::mutex> lock(connected_mut_);
+	auto connection_completed = [this]() { return connected_ || conn_.lost(); };
 	if (!connection_completed()) {
 		// start thread if not yet running
 		if (check_thread_start_ && !data_thread_.joinable()) {
@@ -71,10 +72,10 @@ void data_receiver::open_stream(double timeout) {
 		}
 		// wait until the connection attempt completes (or we time out)
 		if (timeout >= FOREVER)
-			connected_upd_.wait(lock, lslboost::bind(&data_receiver::connection_completed,this));
-		else
-			if (!connected_upd_.wait_for(lock, lslboost::chrono::duration<double>(timeout), lslboost::bind(&data_receiver::connection_completed,this)))
-				throw timeout_error("The open_stream() operation timed out.");
+			connected_upd_.wait(lock, connection_completed);
+		else if (!connected_upd_.wait_for(
+					 lock, lslboost::chrono::duration<double>(timeout), connection_completed))
+			throw timeout_error("The open_stream() operation timed out.");
 	}
 	if (conn_.lost())
 		throw lost_error("The stream read by this inlet has been lost. To recover, you need to re-resolve the source and re-create the inlet.");

src/data_receiver.h

@@ -61,9 +61,6 @@ namespace lsl {
 		/// The data reader thread.
 		void data_thread();
 
-		/// Function that is polled by the condition variable
-		bool connection_completed() { return connected_ || conn_.lost(); }
-
 		// the underlying connection
 		inlet_connection &conn_;
 

src/info_receiver.cpp

@@ -30,16 +30,17 @@ info_receiver::~info_receiver() {
 /// Retrieve the complete information of the given stream, including the extended description.
 const stream_info_impl &info_receiver::info(double timeout) {
 	lslboost::unique_lock<lslboost::mutex> lock(fullinfo_mut_);
+	auto info_ready = [this](){ return fullinfo_ || conn_.lost(); };
 	if (!info_ready()) {
 		// start thread if not yet running
 		if (!info_thread_.joinable())
 			info_thread_ = lslboost::thread(&info_receiver::info_thread,this);
 		// wait until we are ready to return a result (or we time out)
 		if (timeout >= FOREVER)
-			fullinfo_upd_.wait(lock, lslboost::bind(&info_receiver::info_ready,this));
-		else
-			if (!fullinfo_upd_.wait_for(lock, lslboost::chrono::duration<double>(timeout), lslboost::bind(&info_receiver::info_ready,this)))
-				throw timeout_error("The info() operation timed out.");
+			fullinfo_upd_.wait(lock, info_ready);
+		else if (!fullinfo_upd_.wait_for(
+					 lock, lslboost::chrono::duration<double>(timeout), info_ready))
+			throw timeout_error("The info() operation timed out.");
 	}
 	if (conn_.lost())
 		throw lost_error("The stream read by this inlet has been lost. To recover, you need to re-resolve the source and re-create the inlet.");
@@ -91,5 +92,3 @@ void info_receiver::info_thread() {
 	conn_.release_watchdog();
 }
 
-bool info_receiver::info_ready() { return fullinfo_ || conn_.lost(); }
-

src/info_receiver.h

@@ -33,10 +33,6 @@ namespace lsl {
 		/// The info reader thread.
 		void info_thread();
 
-		/// function polled by the condition variable
-		bool info_ready();
-
-
 		// the underlying connection
 		inlet_connection &conn_;					// reference to our connection
 

src/inlet_connection.cpp

@@ -1,7 +1,6 @@
-#include <boost/bind.hpp>
-#include <functional>
 #include "inlet_connection.h"
 #include "api_config.h"
+#include <functional>
 
 
 // === implementation of the inlet_connection class ===
@@ -246,7 +245,10 @@ void inlet_connection::watchdog_thread() {
 			// so that the watchdog can be cancelled conveniently
 			{
 				lslboost::unique_lock<lslboost::mutex> lock(shutdown_mut_);
-				shutdown_cond_.wait_for(lock,lslboost::chrono::duration<double>(api_config::get_instance()->watchdog_check_interval()), lslboost::bind(&inlet_connection::shutdown,this));
+				shutdown_cond_.wait_for(lock,
+					lslboost::chrono::duration<double>(
+						api_config::get_instance()->watchdog_check_interval()),
+					[this]() { return shutdown(); });
 			}
 		} catch(std::exception &e) {
 			LOG_F(ERROR, "Unexpected hiccup in the watchdog thread: %s", e.what());

src/resolver_impl.cpp

@@ -13,6 +13,7 @@
 
 using namespace lsl;
 using namespace lslboost::asio;
+using err_t = const lslboost::system::error_code&;
 
 /**
 * Instantiate a new resolver and configure timing parameters.
@@ -83,7 +84,9 @@ std::vector<stream_info_impl> resolver_impl::resolve_oneshot(const std::string &
 	// start a timer that cancels all outstanding IO operations and wave schedules after the timeout has expired
 	if (timeout != FOREVER) {
 		resolve_timeout_expired_.expires_after(timeout_sec(timeout));
-		resolve_timeout_expired_.async_wait(lslboost::bind(&resolver_impl::resolve_timeout_expired,this,placeholders::error));
+		resolve_timeout_expired_.async_wait([this](err_t err) {
+			if (err != error::operation_aborted) cancel_ongoing_resolve();
+		});
 	}
 
 	// start the first wave of resolve packets
@@ -148,17 +151,20 @@ void resolver_impl::next_resolve_wave() {
 	} else {
 		// start a new multicast wave
 		udp_multicast_burst();
+
+		auto wave_timer_timeout =
+			(fast_mode_ ? 0 : cfg_->continuous_resolve_interval()) + cfg_->multicast_min_rtt();
 		if (!ucast_endpoints_.empty()) {
-			// we have known peer addresses: we spawn a unicast wave and shortly thereafter the next wave
+			// we have known peer addresses: we spawn a unicast wave
 			unicast_timer_.expires_after(timeout_sec(cfg_->multicast_min_rtt()));
-			unicast_timer_.async_wait(lslboost::bind(&resolver_impl::udp_unicast_burst,this,placeholders::error));
-			wave_timer_.expires_after(timeout_sec((fast_mode_?0:cfg_->continuous_resolve_interval())+(cfg_->multicast_min_rtt()+cfg_->unicast_min_rtt())));
-			wave_timer_.async_wait(lslboost::bind(&resolver_impl::wave_timeout_expired,this,placeholders::error));
-		} else {
-			// there are no known peer addresses; just set up the next wave
-			wave_timer_.expires_after(timeout_sec((fast_mode_?0:cfg_->continuous_resolve_interval())+cfg_->multicast_min_rtt()));
-			wave_timer_.async_wait(lslboost::bind(&resolver_impl::wave_timeout_expired,this,placeholders::error));
+			unicast_timer_.async_wait([this](err_t ec) { this->udp_unicast_burst(ec); });
+			// delay the next multicast wave
+			wave_timer_timeout += cfg_->unicast_min_rtt();
 		}
+		wave_timer_.expires_after(timeout_sec(wave_timer_timeout));
+		wave_timer_.async_wait([this](err_t err) {
+			if (err != error::operation_aborted) next_resolve_wave();
+		});
 	}
 }
 
@@ -199,19 +205,6 @@ void resolver_impl::udp_unicast_burst(error_code err) {
 	}
 }
 
-/// This handler is called when the overall resolve timeout (if any) expires.
-void resolver_impl::resolve_timeout_expired(error_code err) {
-	if (err != error::operation_aborted)
-		cancel_ongoing_resolve();
-}
-
-/// This handler is called when the wave timeout expires.
-void resolver_impl::wave_timeout_expired(error_code err) {
-	if (err != error::operation_aborted)
-		next_resolve_wave();
-}
-
-
 // === cancellation and teardown ===
 
 /// Cancel any ongoing operations and render the resolver unusable.
@@ -226,10 +219,10 @@ void resolver_impl::cancel_ongoing_resolve() {
 	// make sure that ongoing handler loops terminate
 	expired_ = true;
 	// timer fires: cancel the next wave schedule
-	post(*io_, lslboost::bind(&steady_timer::cancel, &wave_timer_));
-	post(*io_, lslboost::bind(&steady_timer::cancel, &unicast_timer_));
+	post(*io_, [this]() { wave_timer_.cancel(); });
+	post(*io_, [this]() { unicast_timer_.cancel(); });
 	// and cancel the timeout, too
-	post(*io_, lslboost::bind(&steady_timer::cancel, &resolve_timeout_expired_));
+	post(*io_, [this]() { resolve_timeout_expired_.cancel(); });
 	// cancel all currently active resolve attempts
 	cancel_all_registered();
 }

src/resolver_impl.h

@@ -91,12 +91,6 @@ namespace lsl {
 		/// Start a new resolver attempt on the known peers.
 		void udp_unicast_burst(error_code err);
 
-		/// This handler is called when the overall timeout (if any) expires.
-		void resolve_timeout_expired(error_code err);
-
-		/// This handler is called when the wave timeout (if any) expires.
-		void wave_timeout_expired(error_code err);
-
 		/// Cancel the currently ongoing resolve, if any.
 		void cancel_ongoing_resolve();
 

src/send_buffer.cpp

@@ -1,6 +1,5 @@
 #include "send_buffer.h"
 #include "consumer_queue.h"
-#include <boost/bind.hpp>
 #include <memory>
 
 
@@ -63,6 +62,7 @@ bool send_buffer::have_consumers() {
 /// Wait until some consumers are present.
 bool send_buffer::wait_for_consumers(double timeout) {
 	lslboost::unique_lock<lslboost::mutex> lock(consumers_mut_);
-	return some_registered_.wait_for(lock, lslboost::chrono::duration<double>(timeout), lslboost::bind(&send_buffer::some_registered,this));
+	return some_registered_.wait_for(
+		lock, lslboost::chrono::duration<double>(timeout), [this]() { return some_registered(); });
 }
 

src/stream_inlet_impl.h

@@ -1,7 +1,6 @@
 #ifndef STREAM_INLET_IMPL_H
 #define STREAM_INLET_IMPL_H
 
-#include <boost/bind.hpp>
 #include "data_receiver.h"
 #include "time_receiver.h"
 #include "common.h"
@@ -32,11 +31,13 @@ namespace lsl {
 		*				 In all other cases (recover is false or the stream is not recoverable) a lost_error is thrown where 
 		*				 indicated if the stream's source is lost (e.g., due to an app or computer crash).
 		*/
-		stream_inlet_impl(const stream_info_impl &info, int32_t max_buflen=360, int32_t max_chunklen=0, bool recover=true): conn_(info,recover), info_receiver_(conn_), time_receiver_(conn_), data_receiver_(conn_,max_buflen,max_chunklen),
-			postprocessor_(lslboost::bind(&time_receiver::time_correction,&time_receiver_,5), 
-			lslboost::bind(&inlet_connection::current_srate,&conn_),
-			lslboost::bind(&time_receiver::was_reset,&time_receiver_)) 
-		{
+		stream_inlet_impl(const stream_info_impl &info, int32_t max_buflen = 360,
+			int32_t max_chunklen = 0, bool recover = true)
+			: conn_(info, recover), info_receiver_(conn_), time_receiver_(conn_),
+			  data_receiver_(conn_, max_buflen, max_chunklen),
+			  postprocessor_([this]() { return time_receiver_.time_correction(5); },
+				  [this]() { return conn_.current_srate(); },
+				  [this]() { return time_receiver_.was_reset(); }) {
 			ensure_lsl_initialized();
 			conn_.engage();
 		}

src/stream_outlet_impl.cpp

@@ -1,7 +1,6 @@
 #include "stream_outlet_impl.h"
 #include "tcp_server.h"
 #include "udp_server.h"
-#include <boost/bind.hpp>
 #include <boost/thread/thread_only.hpp>
 #include <memory>
 
@@ -46,9 +45,19 @@ stream_outlet_impl::stream_outlet_impl(const stream_info_impl &info, int chunk_s
 	for (auto &responder : responders_) responder->begin_serving();
 
 	// and start the IO threads to handle them
+	const std::string name{"IO_" + this->info().name().substr(0, 11)};
 	for (const auto &io : ios_)
-		io_threads_.push_back(std::make_shared<lslboost::thread>(
-			lslboost::bind(&stream_outlet_impl::run_io, this, io)));
+		io_threads_.emplace_back(std::make_shared<lslboost::thread>([io, name]() {
+			loguru::set_thread_name(name.c_str());
+			while (true) {
+				try {
+					io->run();
+					return;
+				} catch (std::exception &e) {
+					LOG_F(ERROR, "Error during io_context processing: %s", e.what());
+				}
+			}
+		}));
 }
 
 /**
@@ -111,19 +120,6 @@ stream_outlet_impl::~stream_outlet_impl() {
 	} catch (...) { LOG_F(ERROR, "Severe error during stream outlet shutdown."); }
 }
 
-// Run an IO service.
-void stream_outlet_impl::run_io(io_context_p &ios) {
-	loguru::set_thread_name((std::string("IO_") += info().name().substr(0, 11)).c_str());
-	while (true) {
-		try {
-			ios->run();
-			return;
-		} catch(std::exception &e) {
-			LOG_F(ERROR, "Error during io_context processing: %s", e.what());
-		}
-	}
-}
-
 /**
 * Retrieve the stream info associated with this outlet.
 * This is the constant meta-data header that was used to create the stream.