Merge remote-tracking branch 'upstream/master' into dev-speedy

Author: jfrey-xx

.travis.yml

@@ -7,20 +7,13 @@ matrix:
   - os: osx
     osx_image: xcode10.1
     env: OSXVER=MacOS10.13
-  - os: osx
-    osx_image: xcode9.2
-    env: OSXVER=MacOS10.12
-  - os: osx
-    osx_image: xcode8
-    env: OSXVER=MacOS10.11
 before_script:
 - brew update
 - brew upgrade cmake
 script:
-- mkdir -p build/install
-- cd build
 - cmake --version
-- cmake -DCMAKE_BUILD_TYPE=Release -DLSL_UNIXFOLDERS=1 ${CMakeArgs} -DLSL_UNITTESTS=1 ../
+- cmake -S . -B build ${CMakeArgs} -DLSL_UNITTESTS=1
+- cd build
 - cmake --build . --config Release --target install
 - testing/lsl_test_internal || true
 - testing/lsl_test_exported

CMakeLists.txt

@@ -25,7 +25,7 @@ set(LSL_WINVER "0x0601" CACHE STRING
 	"Windows version (_WIN32_WINNT) to target (defaults to 0x0601 for Windows 7)")
 
 # Add an object library so all files are only compiled once
-set(lslobj_sources
+add_library(lslobj OBJECT
 	src/api_config.cpp
 	src/api_config.h
 	src/api_types.hpp
@@ -96,7 +96,6 @@ set(lslobj_sources
 	include/lsl/types.h
 	include/lsl/xml.h
 )
-add_library(lslobj OBJECT ${lslobj_sources})
 
 # try to find out which revision is currently checked out
 find_package(Git)
@@ -120,11 +119,9 @@ else()
 	set(lslgitrevision "unknown")
 	set(lslgitbranch "unknown")
 endif()
-set(LSL_VERSION_INFO "\"git:${lslgitrevision}/branch:${lslgitbranch}/build:${CMAKE_BUILD_TYPE}/compiler:${CMAKE_CXX_COMPILER_ID}-${CMAKE_CXX_COMPILER_VERSION}/boost:\" BOOST_LIB_VERSION")
-set_source_files_properties("src/common.cpp" PROPERTIES COMPILE_DEFINITIONS LSL_LIBRARY_INFO_STR=${LSL_VERSION_INFO})
+set(LSL_VERSION_INFO "git:${lslgitrevision}/branch:${lslgitbranch}/build:${CMAKE_BUILD_TYPE}/compiler:${CMAKE_CXX_COMPILER_ID}-${CMAKE_CXX_COMPILER_VERSION}")
 set_source_files_properties("src/loguru/loguru.cpp" PROPERTIES COMPILE_DEFINITIONS LOGURU_STACKTRACES=$<BOOL:${LSL_DEBUGLOG}>)
 
-
 ## create the lslboost target
 add_library(lslboost OBJECT
 	lslboost/asio_objects.cpp
@@ -139,7 +136,7 @@ if (UNIX)
 	)
 	find_package(Threads REQUIRED)
 	target_link_libraries(lslboost PUBLIC Threads::Threads)
-	target_compile_features(lslboost PUBLIC cxx_std_11)
+	target_compile_features(lslboost PUBLIC cxx_std_11 cxx_lambda_init_captures)
 else ()  # WIN32
 	target_sources(lslboost PRIVATE
 		lslboost/libs/serialization/src/codecvt_null.cpp
@@ -165,7 +162,12 @@ target_include_directories(lslboost PUBLIC
 	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/lslboost>)
 
 
-target_link_libraries(lslobj PRIVATE lslboost)
+target_link_libraries(lslobj
+	PRIVATE
+		lslboost
+	PUBLIC
+		$<$<AND:$<BOOL:${LSL_DEBUGLOG}>,$<PLATFORM_ID:Linux>>:dl>
+	)
 target_include_directories(lslobj
 	PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
 )
@@ -176,37 +178,24 @@ target_compile_definitions(lslobj
 )
 
 # shared library
-if (CMAKE_GENERATOR MATCHES "Xcode")
-    # Xcode is rather annoying in that it doesn't build SHARED libs unless they have source files.
-    # So we need to build from source, and then add all the other settings missing due to lack of lslobj
-    add_library(lsl SHARED ${lslobj_sources})
-    target_link_libraries(lsl PRIVATE lslboost)
-else()
-    add_library(lsl SHARED)
-    target_link_libraries(lsl
-		PUBLIC lslobj
-		PRIVATE lslboost)
-endif()
-target_include_directories(lsl
-	PUBLIC
-		$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
-		$<INSTALL_INTERFACE:include>
-)
-target_compile_definitions(lsl
-	PRIVATE LIBLSL_EXPORTS $<$<PLATFORM_ID:Windows>:_CRT_SECURE_NO_WARNINGS>
-	INTERFACE LSLNOAUTOLINK # don't use #pragma(lib) in CMake builds
-)
-
+add_library(lsl SHARED src/buildinfo.cpp)
+target_compile_definitions(lsl PRIVATE
+	LSL_LIBRARY_INFO_STR="${LSL_VERSION_INFO}/link:shared"
+	LIBLSL_EXPORTS)
+target_link_libraries(lsl
+	PUBLIC lslobj
+	PRIVATE lslboost)
 set_target_properties(lsl PROPERTIES
 	VERSION ${liblsl_VERSION_MAJOR}.${liblsl_VERSION_MINOR}.${liblsl_VERSION_PATCH}
 )
 
 set(LSL_EXPORT_TARGETS lsl lslobj lslboost)
 if(LSL_BUILD_STATIC)
-	add_library(lsl-static STATIC)
+	add_library(lsl-static STATIC src/buildinfo.cpp)
+	target_compile_definitions(lsl-static PRIVATE LSL_LIBRARY_INFO_STR="${LSL_VERSION_INFO}/link:static")
 	target_link_libraries(lsl-static PUBLIC lslobj PRIVATE lslboost)
 	# for LSL_CPP_API export header
-	target_compile_definitions(lsl-static INTERFACE LIBLSL_STATIC)
+	target_compile_definitions(lsl-static PUBLIC LIBLSL_STATIC)
 endif()
 
 if(LSL_FORCE_FANCY_LIBNAME)

include/lsl/common.h

@@ -171,7 +171,7 @@ extern LIBLSL_C_API int32_t lsl_library_version();
  *
  * The format of the string shouldn't be used for anything important except giving a debugging
  * person a good idea which exact library version is used. */
-extern LIBLSL_C_API const char *lsl_library_info();
+extern LIBLSL_C_API const char *lsl_library_info(void);
 
 /**
  * Obtain a local system time stamp in seconds.

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;
 
@@ -76,7 +77,10 @@ void api_config::load_from_file(const std::string &filename) {
 		INI pt;
 		if (!filename.empty()) {
 			std::ifstream infile(filename);
-			if (infile.good()) pt.load(infile);
+			if (infile.good()) {
+				LOG_F(INFO, "Loading configuration from %s", filename.c_str());
+				pt.load(infile);
+			}
 		}
 
 		// read out the [ports] parameters
@@ -206,7 +210,7 @@ void api_config::load_from_file(const std::string &filename) {
 		force_default_timestamps_ = pt.get("tuning.ForceDefaultTimestamps", false);
 
 		// read the [log] settings
-		int log_level = pt.get("log.level", -1);
+		int log_level = pt.get("log.level", (int) loguru::Verbosity_INFO);
 		if (log_level < -3 || log_level > 9)
 			throw std::runtime_error("Invalid log.level (valid range: -3 to 9");
 
@@ -228,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/buildinfo.cpp

@@ -0,0 +1,11 @@
+extern "C" {
+#include "../include/lsl/common.h"
+
+LIBLSL_C_API const char *lsl_library_info(void) {
+#ifdef LSL_LIBRARY_INFO_STR
+	return LSL_LIBRARY_INFO_STR;
+#else
+	return "Unknown (not set by build system)";
+#endif
+}
+}

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/common.cpp

@@ -20,14 +20,6 @@ LIBLSL_C_API int32_t lsl_protocol_version() {
 
 LIBLSL_C_API int32_t lsl_library_version() { return LSL_LIBRARY_VERSION; }
 
-LIBLSL_C_API const char *lsl_library_info() {
-#ifdef LSL_LIBRARY_INFO_STR
-	return LSL_LIBRARY_INFO_STR;
-#else
-	return "Unknown (not set by build system)";
-#endif
-}
-
 LIBLSL_C_API double lsl_local_clock() {
 	return lslboost::chrono::nanoseconds(
 			   lslboost::chrono::high_resolution_clock::now().time_since_epoch())
@@ -49,7 +41,7 @@ void lsl::ensure_lsl_initialized() {
 	if (!is_initialized) {
 		is_initialized = true;
 
-		loguru::g_stderr_verbosity = loguru::Verbosity_WARNING;
+		loguru::g_stderr_verbosity = loguru::Verbosity_INFO;
 #ifdef LOGURU_DEBUG_LOGGING
 		// Initialize loguru, mainly to print stacktraces on segmentation faults
 		int argc = 1;

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())
@@ -71,7 +71,7 @@ void data_receiver::close_stream() {
 }
 
 template <class T>
-double data_receiver::pull_sample_typed(T *buffer, int buffer_elements, double timeout) {
+double data_receiver::pull_sample_typed(T *buffer, uint32_t buffer_elements, double timeout) {
 	if (conn_.lost())
 		throw lost_error("The stream read by this outlet has been lost. To recover, you need to "
 						 "re-resolve the source and re-create the inlet.");
@@ -95,13 +95,13 @@ double data_receiver::pull_sample_typed(T *buffer, int buffer_elements, double t
 	}
 }
 
-template double data_receiver::pull_sample_typed<char>(char *, int, double);
-template double data_receiver::pull_sample_typed<int16_t>(int16_t *, int, double);
-template double data_receiver::pull_sample_typed<int32_t>(int32_t *, int, double);
-template double data_receiver::pull_sample_typed<int64_t>(int64_t *, int, double);
-template double data_receiver::pull_sample_typed<float>(float *, int, double);
-template double data_receiver::pull_sample_typed<double>(double *, int, double);
-template double data_receiver::pull_sample_typed<std::string>(std::string *, int, double);
+template double data_receiver::pull_sample_typed<char>(char *, uint32_t, double);
+template double data_receiver::pull_sample_typed<int16_t>(int16_t *, uint32_t, double);
+template double data_receiver::pull_sample_typed<int32_t>(int32_t *, uint32_t, double);
+template double data_receiver::pull_sample_typed<int64_t>(int64_t *, uint32_t, double);
+template double data_receiver::pull_sample_typed<float>(float *, uint32_t, double);
+template double data_receiver::pull_sample_typed<double>(double *, uint32_t, double);
+template double data_receiver::pull_sample_typed<std::string>(std::string *, uint32_t, double);
 
 double data_receiver::pull_sample_untyped(void *buffer, int buffer_bytes, double timeout) {
 	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();