Store reference to resolver_impl instead of all result vars

Author: tstenner

src/resolve_attempt_udp.cpp

@@ -13,11 +13,11 @@
 using namespace lsl;
 
 resolve_attempt_udp::resolve_attempt_udp(asio::io_context &io, const udp &protocol,
-	const std::vector<udp::endpoint> &targets, const std::string &query, result_container &results,
-	std::mutex &results_mut, double cancel_after, cancellable_registry *registry)
-	: io_(io), results_(results), results_mut_(results_mut), cancel_after_(cancel_after),
-	  cancelled_(false), targets_(targets), query_(query), unicast_socket_(io),
-	  broadcast_socket_(io), multicast_socket_(io), recv_socket_(io), cancel_timer_(io) {
+	const std::vector<udp::endpoint> &targets, const std::string &query, resolver_impl &resolver,
+	double cancel_after)
+	: io_(io), resolver_(resolver), cancel_after_(cancel_after), cancelled_(false),
+	  targets_(targets), query_(query), unicast_socket_(io), broadcast_socket_(io),
+	  multicast_socket_(io), recv_socket_(io), cancel_timer_(io) {
 	// open the sockets that we might need
 	recv_socket_.open(protocol);
 	try {
@@ -57,7 +57,7 @@ resolve_attempt_udp::resolve_attempt_udp(asio::io_context &io, const udp &protoc
 		query_msg_.c_str());
 
 	// register ourselves as a candidate for cancellation
-	if (registry) register_at(registry);
+	register_at(&resolver);
 }
 
 resolve_attempt_udp::~resolve_attempt_udp() {
@@ -116,20 +116,24 @@ void resolve_attempt_udp::handle_receive_outcome(err_t err, std::size_t len) {
 				std::string uid = info.uid();
 				{
 					// update the results
-					std::lock_guard<std::mutex> lock(results_mut_);
-					if (results_.find(uid) == results_.end())
-						results_[uid] = std::make_pair(info, lsl_clock()); // insert new result
+					std::lock_guard<std::mutex> lock(resolver_.results_mut_);
+					auto it = resolver_.results_.find(uid);
+					if (it == resolver_.results_.end())
+						// insert new result, store iterator in it
+						it = resolver_.results_.emplace(uid, std::make_pair(info, lsl_clock()))
+								 .first;
 					else
-						results_[uid].second = lsl_clock(); // update only the receive time
+						it->second.second = lsl_clock(); // update only the receive time
+					auto &stored_info = it->second.first;
 					// ... also update the address associated with the result (but don't
 					// override the address of an earlier record for this stream since this
 					// would be the faster route)
 					if (remote_endpoint_.address().is_v4()) {
-						if (results_[uid].first.v4address().empty())
-							results_[uid].first.v4address(remote_endpoint_.address().to_string());
+						if (stored_info.v4address().empty())
+							stored_info.v4address(remote_endpoint_.address().to_string());
 					} else {
-						if (results_[uid].first.v6address().empty())
-							results_[uid].first.v6address(remote_endpoint_.address().to_string());
+						if (stored_info.v6address().empty())
+							stored_info.v6address(remote_endpoint_.address().to_string());
 					}
 				}
 			}

src/resolve_attempt_udp.h

@@ -53,8 +53,7 @@ class resolve_attempt_udp : public cancellable_obj,
 	 */
 	resolve_attempt_udp(asio::io_context &io, const udp &protocol,
 		const std::vector<udp::endpoint> &targets, const std::string &query,
-		result_container &results, std::mutex &results_mut, double cancel_after = 5.0,
-		cancellable_registry *registry = nullptr);
+		resolver_impl &resolver, double cancel_after = 5.0);
 
 	/// Destructor
 	~resolve_attempt_udp();
@@ -90,10 +89,8 @@ class resolve_attempt_udp : public cancellable_obj,
 	// data shared with the resolver_impl
 	/// reference to the IO service that executes our actions
 	asio::io_context &io_;
-	/// shared result container
-	result_container &results_;
-	/// shared mutex that protects the results
-	std::mutex &results_mut_;
+	/// the resolver associated with this attempt
+	resolver_impl &resolver_;
 
 	// constant over the lifetime of this attempt
 	/// the timeout for giving up

src/resolver_impl.cpp

@@ -206,8 +206,8 @@ void resolver_impl::udp_multicast_burst() {
 	int failures = 0;
 	for (auto protocol: udp_protocols_) {
 		try {
-			std::make_shared<resolve_attempt_udp>(*io_, protocol, mcast_endpoints_, query_,
-				results_, results_mut_, cfg_->multicast_max_rtt(), this)
+			std::make_shared<resolve_attempt_udp>(
+				*io_, protocol, mcast_endpoints_, query_, *this, cfg_->multicast_max_rtt())
 				->begin();
 		} catch (std::exception &e) {
 			if (++failures == udp_protocols_.size())
@@ -226,8 +226,8 @@ void resolver_impl::udp_unicast_burst(err_t err) {
 	// start one per IP stack under consideration
 	for (auto protocol: udp_protocols_) {
 		try {
-			std::make_shared<resolve_attempt_udp>(*io_, protocol, ucast_endpoints_, query_,
-				results_, results_mut_, cfg_->unicast_max_rtt(), this)
+			std::make_shared<resolve_attempt_udp>(
+				*io_, protocol, ucast_endpoints_, query_, *this, cfg_->unicast_max_rtt())
 				->begin();
 		} catch (std::exception &e) {
 			if (++failures == udp_protocols_.size())

src/resolver_impl.h

@@ -129,6 +129,8 @@ class resolver_impl : public cancellable_registry {
 	};
 
 private:
+	friend class resolve_attempt_udp;
+
 	/// This function starts a new wave of resolves.
 	void next_resolve_wave();