Prevent invalid resolver operations

Throws an exception on some illegal operations
(e.g. starting a resolve operation while a continuous resolve operation
is in progress, retrieving results before starting a resolve operation)

Author: tstenner

include/lsl_cpp.h

@@ -1668,7 +1668,7 @@ class continuous_resolver {
 	std::vector<stream_info> results() {
 		lsl_streaminfo buffer[1024];
 		return std::vector<stream_info>(
-			buffer, buffer + lsl_resolver_results(obj.get(), buffer, sizeof(buffer)));
+			buffer, buffer + check_error(lsl_resolver_results(obj.get(), buffer, sizeof(buffer))));
 	}
 
 	/// Move constructor for stream_inlet

src/resolver_impl.cpp

@@ -90,6 +90,9 @@ resolver_impl *resolver_impl::create_resolver(
 
 std::vector<stream_info_impl> resolver_impl::resolve_oneshot(
 	const std::string &query, int minimum, double timeout, double minimum_time) {
+	if(status == resolver_status::running_continuous)
+		throw std::logic_error("resolve_oneshot called during continuous operation");
+
 	check_query(query);
 	// reset the IO service & set up the query parameters
 	io_->restart();
@@ -113,6 +116,8 @@ std::vector<stream_info_impl> resolver_impl::resolve_oneshot(
 	// start the first wave of resolve packets
 	next_resolve_wave();
 
+	status = resolver_status::started_oneshot;
+
 	// run the IO operations until finished
 	if (!cancelled_) {
 		io_->run();
@@ -125,6 +130,9 @@ std::vector<stream_info_impl> resolver_impl::resolve_oneshot(
 }
 
 void resolver_impl::resolve_continuous(const std::string &query, double forget_after) {
+	if(status == resolver_status::running_continuous)
+		throw std::logic_error("resolve_continuous called during another continuous operation");
+
 	check_query(query);
 	// reset the IO service & set up the query parameters
 	io_->restart();
@@ -139,9 +147,13 @@ void resolver_impl::resolve_continuous(const std::string &query, double forget_a
 	next_resolve_wave();
 	// spawn a thread that runs the IO operations
 	background_io_ = std::make_shared<std::thread>([shared_io = io_]() { shared_io->run(); });
+	status = resolver_status::running_continuous;
 }
 
 std::vector<stream_info_impl> resolver_impl::results(uint32_t max_results) {
+	if (status == resolver_status::empty)
+		throw std::logic_error("results() called before starting a resolve operation");
+
 	std::vector<stream_info_impl> output;
 	std::lock_guard<std::mutex> lock(results_mut_);
 	double expired_before = lsl_clock() - forget_after_;

src/resolver_impl.h

@@ -124,6 +124,10 @@ class resolver_impl : public cancellable_registry {
 	 */
 	void cancel();
 
+	enum class resolver_status {
+		empty, started_oneshot, running_continuous
+	};
+
 private:
 	/// This function starts a new wave of resolves.
 	void next_resolve_wave();
@@ -157,6 +161,7 @@ class resolver_impl : public cancellable_registry {
 	std::atomic<bool> expired_;
 
 	// reinitialized for each query
+	resolver_status status{resolver_status::empty};
 	/// our current query string
 	std::string query_;
 	/// the minimum number of results that we want