Use stdlib mutexes instead of boost mutexes where possible

Author: tstenner

src/api_config.cpp

@@ -1,8 +1,9 @@
 #include "api_config.h"
 #include "common.h"
 #include "inireader.h"
-#include <boost/thread/once.hpp>
+#include <algorithm>
 #include <fstream>
+#include <mutex>
 
 using namespace lsl;
 
@@ -231,16 +232,14 @@ void api_config::load_from_file(const std::string &filename) {
 	}
 }
 
+static std::once_flag api_config_once_flag;
+
 const api_config *api_config::get_instance() {
-	lslboost::call_once(&called_once, once_flag);
+	std::call_once(api_config_once_flag, []() { api_config::get_instance_internal(); });
 	return get_instance_internal();
 }
 
 api_config *api_config::get_instance_internal() {
 	static api_config cfg;
 	return &cfg;
 }
-
-void api_config::called_once() { get_instance_internal(); }
-
-lslboost::once_flag api_config::once_flag = BOOST_ONCE_INIT;

src/api_config.h

@@ -5,9 +5,6 @@
 #include <vector>
 
 #include "common.h"
-namespace lslboost {
-struct once_flag;
-}
 
 namespace lsl {
 /**
@@ -194,10 +191,8 @@ class api_config {
 	api_config &operator=(const api_config &rhs) = delete;
 
 private:
-	// Thread-safe initialization logic (boilerplate).
-	static lslboost::once_flag once_flag;
+	/// Get the api_config singleton after thread-safe initialization if needed
 	static api_config *get_instance_internal();
-	static void called_once();
 
 	/**
 	 * Constructor.

src/cancellable_streambuf.h

@@ -65,7 +65,7 @@ class cancellable_streambuf : public std::streambuf,
 	 */
 	void cancel() {
 		cancel_issued_ = true;
-		lslboost::lock_guard<lslboost::recursive_mutex> lock(cancel_mut_);
+		std::lock_guard<std::recursive_mutex> lock(cancel_mut_);
 		cancel_started_ = false;
 		this->get_service().get_io_context().post([this]() { close_if_open(); });
 	}
@@ -80,7 +80,7 @@ class cancellable_streambuf : public std::streambuf,
 	 */
 	cancellable_streambuf *connect(const Protocol::endpoint &endpoint) {
 		{
-			lslboost::lock_guard<lslboost::recursive_mutex> lock(cancel_mut_);
+			std::lock_guard<std::recursive_mutex> lock(cancel_mut_);
 			if (cancel_issued_)
 				throw std::runtime_error(
 					"Attempt to connect() a cancellable_streambuf after it has been cancelled.");
@@ -130,7 +130,7 @@ class cancellable_streambuf : public std::streambuf,
 	/// This function makes sure that a cancellation, if issued, is not being eaten by the
 	/// io_context reset()
 	void protected_reset() {
-		lslboost::lock_guard<lslboost::recursive_mutex> lock(cancel_mut_);
+		std::lock_guard<std::recursive_mutex> lock(cancel_mut_);
 		// if the cancel() comes between completion of a run_one() and this call, close will be
 		// issued right here at the next opportunity
 		if (cancel_issued_) close_if_open();
@@ -224,7 +224,7 @@ class cancellable_streambuf : public std::streambuf,
 	std::size_t bytes_transferred_;
 	bool cancel_issued_;
 	bool cancel_started_;
-	lslboost::recursive_mutex cancel_mut_;
+	std::recursive_mutex cancel_mut_;
 };
 } // namespace lsl
 

src/cancellation.h

@@ -1,8 +1,7 @@
 #ifndef CANCELLATION_H
 #define CANCELLATION_H
 
-#include <boost/thread/lock_guard.hpp>
-#include <boost/thread/recursive_mutex.hpp>
+#include <mutex>
 #include <set>
 
 namespace lsl {
@@ -30,22 +29,22 @@ class cancellable_registry {
 
 	/// Register a cancellable object.
 	void register_cancellable(class cancellable_obj *o) {
-		lslboost::lock_guard<lslboost::recursive_mutex> lock(state_mut_);
+		std::lock_guard<std::recursive_mutex> lock(state_mut_);
 		if (shutdown_issued_)
 			throw shutdown_error(
 				"The registry has begun to shut down; no new registrations possible.");
 		cancellables_.insert(o);
 	}
 	/// Unregister a cancellable object.
 	void unregister_cancellable(class cancellable_obj *o) {
-		lslboost::lock_guard<lslboost::recursive_mutex> lock(state_mut_);
+		std::lock_guard<std::recursive_mutex> lock(state_mut_);
 		cancellables_.erase(o);
 	}
 
 	bool shutdown_issued_{false}; // whether a shutdown has been issued
 	std::set<cancellable_obj *>
 		cancellables_; // a set of objects that we have to cancel upon re-resolves & disengage
-	lslboost::recursive_mutex state_mut_; // mutex to protect the registry's state
+	std::recursive_mutex state_mut_; // mutex to protect the registry's state
 };
 
 
@@ -77,15 +76,15 @@ class cancellable_obj {
 
 /// Cancel all registered objects.
 inline void cancellable_registry::cancel_all_registered() {
-	lslboost::lock_guard<lslboost::recursive_mutex> lock(state_mut_);
+	std::lock_guard<std::recursive_mutex> lock(state_mut_);
 	std::set<cancellable_obj *> copy(cancellables_);
 	for (auto obj : copy)
 		if (cancellables_.find(obj) != cancellables_.end()) obj->cancel();
 }
 
 /// Cancel and prevent future object registrations.
 inline void cancellable_registry::cancel_and_shutdown() {
-	lslboost::lock_guard<lslboost::recursive_mutex> lock(state_mut_);
+	std::lock_guard<std::recursive_mutex> lock(state_mut_);
 	shutdown_issued_ = true;
 	cancel_all_registered();
 }

src/consumer_queue.cpp

@@ -3,6 +3,7 @@
 #include "sample.h"
 #include "send_buffer.h"
 #include <boost/chrono/duration.hpp>
+#include <boost/thread/thread_only.hpp>
 
 using namespace lsl;
 

src/data_receiver.cpp

@@ -44,7 +44,7 @@ data_receiver::~data_receiver() {
 
 void data_receiver::open_stream(double timeout) {
 	closing_stream_ = false;
-	lslboost::unique_lock<lslboost::mutex> lock(connected_mut_);
+	std::unique_lock<std::mutex> lock(connected_mut_);
 	auto connection_completed = [this]() { return connected_ || conn_.lost(); };
 	if (!connection_completed()) {
 		// start thread if not yet running
@@ -56,7 +56,7 @@ void data_receiver::open_stream(double timeout) {
 		if (timeout >= FOREVER)
 			connected_upd_.wait(lock, connection_completed);
 		else if (!connected_upd_.wait_for(
-					 lock, lslboost::chrono::duration<double>(timeout), connection_completed))
+					 lock, std::chrono::duration<double>(timeout), connection_completed))
 			throw timeout_error("The open_stream() operation timed out.");
 	}
 	if (conn_.lost())
@@ -296,7 +296,7 @@ void data_receiver::data_thread() {
 				// been successful, so we're now connected (and remain to be even if we later
 				// recover silently)
 				{
-					lslboost::lock_guard<lslboost::mutex> lock(connected_mut_);
+					std::lock_guard<std::mutex> lock(connected_mut_);
 					connected_ = true;
 				}
 				connected_upd_.notify_all();

src/data_receiver.h

@@ -4,8 +4,9 @@
 #include "cancellation.h"
 #include "consumer_queue.h"
 #include "inlet_connection.h"
-#include <boost/thread/mutex.hpp>
 #include <boost/thread/thread_only.hpp>
+#include <condition_variable>
+#include <mutex>
 
 using lslboost::asio::ip::tcp;
 
@@ -90,9 +91,9 @@ class data_receiver : public cancellable_registry {
 	/// queue of samples ready to be picked up (populated by the data thread)
 	consumer_queue sample_queue_;
 	/// mutex to protect the connected state
-	lslboost::mutex connected_mut_;
+	std::mutex connected_mut_;
 	/// condition variable to indicate that an update for the connected state is available
-	lslboost::condition_variable connected_upd_;
+	std::condition_variable connected_upd_;
 
 	// internal data used by the reader thread
 	/// the maximum number of samples to be buffered for this inlet

src/info_receiver.cpp

@@ -18,7 +18,7 @@ lsl::info_receiver::~info_receiver() {
 }
 
 const lsl::stream_info_impl &lsl::info_receiver::info(double timeout) {
-	lslboost::unique_lock<lslboost::mutex> lock(fullinfo_mut_);
+	std::unique_lock<std::mutex> lock(fullinfo_mut_);
 	auto info_ready = [this]() { return fullinfo_ || conn_.lost(); };
 	if (!info_ready()) {
 		// start thread if not yet running
@@ -27,8 +27,7 @@ const lsl::stream_info_impl &lsl::info_receiver::info(double timeout) {
 		// wait until we are ready to return a result (or we time out)
 		if (timeout >= FOREVER)
 			fullinfo_upd_.wait(lock, info_ready);
-		else if (!fullinfo_upd_.wait_for(
-					 lock, lslboost::chrono::duration<double>(timeout), info_ready))
+		else if (!fullinfo_upd_.wait_for(lock, std::chrono::duration<double>(timeout), info_ready))
 			throw timeout_error("The info() operation timed out.");
 	}
 	if (conn_.lost())
@@ -61,7 +60,7 @@ void lsl::info_receiver::info_thread() {
 				if (!info.created_at()) continue;
 				// store the result for pickup & return
 				{
-					lslboost::lock_guard<lslboost::mutex> lock(fullinfo_mut_);
+					std::lock_guard<std::mutex> lock(fullinfo_mut_);
 					fullinfo_ = std::make_shared<stream_info_impl>(info);
 				}
 				fullinfo_upd_.notify_all();

src/info_receiver.h

@@ -3,9 +3,9 @@
 
 #include "common.h"
 #include "forward.h"
-#include <boost/thread/condition_variable.hpp>
-#include <boost/thread/mutex.hpp>
 #include <boost/thread/thread_only.hpp>
+#include <condition_variable>
+#include <mutex>
 
 namespace lsl {
 class inlet_connection;
@@ -49,9 +49,9 @@ class info_receiver {
 	/// the full stream_info_impl object (retrieved by the info thread)
 	stream_info_impl_p fullinfo_;
 	/// mutex to protect the fullinfo
-	lslboost::mutex fullinfo_mut_;
+	std::mutex fullinfo_mut_;
 	/// condition variable to indicate that an update for the fullinfo is available
-	lslboost::condition_variable fullinfo_upd_;
+	std::condition_variable fullinfo_upd_;
 };
 
 } // namespace lsl