Use namespace alias for asio, avoid copying error_code in handlers

Author: tstenner

src/data_receiver.h

@@ -10,8 +10,6 @@
 #include <mutex>
 #include <thread>
 
-using lslboost::asio::ip::tcp;
-
 namespace lsl {
 
 class inlet_connection; // Forward declaration

src/forward.h

@@ -22,13 +22,16 @@ class portable_oarchive;
 class portable_iarchive;
 } // namespace eos
 
+namespace asio = lslboost::asio;
+
 namespace lsl {
 /// shared pointers to various classes
 using factory_p = std::shared_ptr<class factory>;
 using sample_p = lslboost::intrusive_ptr<class sample>;
 using send_buffer_p = std::shared_ptr<class send_buffer>;
 using stream_info_impl_p = std::shared_ptr<class stream_info_impl>;
-using io_context_p = std::shared_ptr<lslboost::asio::io_context>;
+using io_context_p = std::shared_ptr<asio::io_context>;
+using string_p = std::shared_ptr<std::string>;
 using tcp_server_p = std::shared_ptr<class tcp_server>;
 using udp_server_p = std::shared_ptr<class udp_server>;
 } // namespace lsl

src/inlet_connection.cpp

@@ -5,8 +5,8 @@
 #include <sstream>
 
 using namespace lsl;
-namespace asio = lslboost::asio;
 namespace ip = asio::ip;
+using lslboost::system::error_code;
 
 inlet_connection::inlet_connection(const stream_info_impl &info, bool recover)
 	: type_info_(info), host_info_(info), tcp_protocol_(tcp::v4()), udp_protocol_(udp::v4()),
@@ -106,7 +106,7 @@ void inlet_connection::disengage() {
 /// convert a IPv6 address or hostname into an non-link-local address
 ip::address resolve_v6_addr(const std::string &addr) {
 	// Try to parse the IPv6 address
-	lslboost::system::error_code ec;
+	error_code ec;
 	auto v6addr = ip::make_address_v6(addr, ec);
 	if (!ec && !v6addr.is_link_local()) return v6addr;
 

src/inlet_connection.h

@@ -25,8 +25,9 @@ using shared_lock_t = lslboost::shared_lock<lslboost::shared_mutex>;
 using unique_lock_t = lslboost::unique_lock<lslboost::shared_mutex>;
 #endif
 
-using lslboost::asio::ip::tcp;
-using lslboost::asio::ip::udp;
+namespace asio = lslboost::asio;
+using asio::ip::tcp;
+using asio::ip::udp;
 
 namespace lsl {
 

src/netinterfaces.cpp

@@ -1,12 +1,12 @@
 #include "netinterfaces.h"
 #include <loguru.hpp>
 
-using lslboost::asio::ip::address_v4;
+using asio::ip::address_v4;
 
-lslboost::asio::ip::address_v6 sinaddr_to_asio(sockaddr_in6 *addr) {
-	lslboost::asio::ip::address_v6::bytes_type buf;
+asio::ip::address_v6 sinaddr_to_asio(sockaddr_in6 *addr) {
+	asio::ip::address_v6::bytes_type buf;
 	memcpy(buf.data(), addr->sin6_addr.s6_addr, sizeof(addr->sin6_addr));
-	return lslboost::asio::ip::make_address_v6(buf, addr->sin6_scope_id);
+	return asio::ip::make_address_v6(buf, addr->sin6_scope_id);
 }
 
 #if defined(_WIN32)
@@ -47,7 +47,7 @@ std::vector<lsl::netif> lsl::get_local_interfaces() {
 				for (Addr *uaddr = addr->FirstUnicastAddress; uaddr != 0; uaddr = uaddr->Next) {
 					if (uaddr->Address.lpSockaddr->sa_family != AF_INET) continue;
 
-					if_.addr = lslboost::asio::ip::make_address_v4(
+					if_.addr = asio::ip::make_address_v4(
 						ntohl(reinterpret_cast<sockaddr_in *>(uaddr->Address.lpSockaddr)
 								  ->sin_addr.s_addr));
 					ret.emplace_back(std::move(if_));
@@ -98,7 +98,7 @@ std::vector<lsl::netif> lsl::get_local_interfaces() {
 		lsl::netif if_;
 
 		if (addr->ifa_addr->sa_family == AF_INET) {
-			if_.addr = lslboost::asio::ip::make_address_v4(
+			if_.addr = asio::ip::make_address_v4(
 				ntohl(reinterpret_cast<sockaddr_in *>(addr->ifa_addr)->sin_addr.s_addr));
 			LOG_F(INFO, "\tIPv4 addr: %x", if_.addr.to_v4().to_uint());
 		} else if (addr->ifa_addr->sa_family == AF_INET6) {

src/netinterfaces.h

@@ -4,11 +4,13 @@
 #include <vector>
 #include <boost/asio/ip/address.hpp>
 
+namespace asio = lslboost::asio;
+
 namespace lsl {
 
 class netif {
 public:
-	lslboost::asio::ip::address addr;
+	asio::ip::address addr;
 	uint32_t ifindex;
 	std::string name;
 };

src/resolve_attempt_udp.cpp

@@ -7,8 +7,6 @@
 #include <sstream>
 
 using namespace lsl;
-namespace asio = lslboost::asio;
-using err_t = const lslboost::system::error_code &;
 
 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,
@@ -93,7 +91,7 @@ void resolve_attempt_udp::receive_next_result() {
 			err_t err, size_t len) { shared_this->handle_receive_outcome(err, len); });
 }
 
-void resolve_attempt_udp::handle_receive_outcome(error_code err, std::size_t len) {
+void resolve_attempt_udp::handle_receive_outcome(err_t err, std::size_t len) {
 	if (cancelled_ || err == asio::error::operation_aborted || err == asio::error::not_connected ||
 		err == asio::error::not_socket)
 		return;
@@ -155,7 +153,7 @@ void resolve_attempt_udp::send_next_query(endpoint_list::const_iterator next) {
 				? broadcast_socket_
 				: (ep.address().is_multicast() ? multicast_socket_ : unicast_socket_);
 		// and send the query over it
-		sock.async_send_to(lslboost::asio::buffer(query_msg_), ep,
+		sock.async_send_to(asio::buffer(query_msg_), ep,
 			[shared_this = shared_from_this(), next](err_t err, size_t /*unused*/) {
 				if (!shared_this->cancelled_ && err != asio::error::operation_aborted &&
 					err != asio::error::not_connected && err != asio::error::not_socket)

src/resolve_attempt_udp.h

@@ -2,19 +2,14 @@
 #define RESOLVE_ATTEMPT_UDP_H
 
 #include "cancellation.h"
+#include "forward.h"
 #include "stream_info_impl.h"
 #include <boost/asio/ip/udp.hpp>
 #include <boost/asio/steady_timer.hpp>
 #include <map>
 
-namespace lslboost {
-namespace system {
-class error_code;
-}
-} // namespace lslboost
-
-using lslboost::asio::ip::udp;
-using lslboost::system::error_code;
+using asio::ip::udp;
+using err_t = const lslboost::system::error_code &;
 
 namespace lsl {
 
@@ -53,7 +48,7 @@ class resolve_attempt_udp : public cancellable_obj,
 	 * @param registry A registry where the attempt can register itself as active so it can be
 	 * cancelled during shutdown.
 	 */
-	resolve_attempt_udp(lslboost::asio::io_context &io, const udp &protocol,
+	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);
@@ -81,7 +76,7 @@ class resolve_attempt_udp : public cancellable_obj,
 	void send_next_query(endpoint_list::const_iterator next);
 
 	/// Handler that gets called when a receive has completed.
-	void handle_receive_outcome(error_code err, std::size_t len);
+	void handle_receive_outcome(err_t err, std::size_t len);
 
 	// === cancellation ===
 
@@ -91,7 +86,7 @@ class resolve_attempt_udp : public cancellable_obj,
 
 	// data shared with the resolver_impl
 	/// reference to the IO service that executes our actions
-	lslboost::asio::io_context &io_;
+	asio::io_context &io_;
 	/// shared result container
 	result_container &results_;
 	/// shared mutex that protects the results
@@ -127,7 +122,7 @@ class resolve_attempt_udp : public cancellable_obj,
 	/// socket to receive replies (always unicast)
 	udp::socket recv_socket_;
 	/// timer to schedule the cancel action
-	lslboost::asio::steady_timer cancel_timer_;
+	asio::steady_timer cancel_timer_;
 };
 } // namespace lsl
 

src/resolver_impl.cpp

@@ -11,9 +11,6 @@
 // === implementation of the resolver_impl class ===
 
 using namespace lsl;
-namespace asio = lslboost::asio;
-namespace ip = asio::ip;
-using err_t = const lslboost::system::error_code &;
 
 resolver_impl::resolver_impl()
 	: cfg_(api_config::get_instance()), cancelled_(false), expired_(false), forget_after_(FOREVER),
@@ -23,7 +20,7 @@ resolver_impl::resolver_impl()
 	uint16_t mcast_port = cfg_->multicast_port();
 	for (const auto &mcast_addr : cfg_->multicast_addresses()) {
 		try {
-			mcast_endpoints_.emplace_back(ip::make_address(mcast_addr), (uint16_t)mcast_port);
+			mcast_endpoints_.emplace_back(asio::ip::make_address(mcast_addr), mcast_port);
 		} catch (std::exception &) {}
 	}
 
@@ -204,7 +201,7 @@ void resolver_impl::udp_multicast_burst() {
 	}
 }
 
-void resolver_impl::udp_unicast_burst(error_code err) {
+void resolver_impl::udp_unicast_burst(err_t err) {
 	if (err == asio::error::operation_aborted) return;
 
 	int failures = 0;

src/resolver_impl.h

@@ -11,9 +11,9 @@
 #include <mutex>
 #include <thread>
 
-using lslboost::asio::ip::tcp;
-using lslboost::asio::ip::udp;
-using lslboost::system::error_code;
+using asio::ip::tcp;
+using asio::ip::udp;
+using err_t = const lslboost::system::error_code &;
 
 namespace lsl {
 class api_config;
@@ -127,7 +127,7 @@ class resolver_impl : public cancellable_registry {
 	void udp_multicast_burst();
 
 	/// Start a new resolver attempt on the known peers.
-	void udp_unicast_burst(error_code err);
+	void udp_unicast_burst(err_t err);
 
 	/// Cancel the currently ongoing resolve, if any.
 	void cancel_ongoing_resolve();
@@ -174,11 +174,11 @@ class resolver_impl : public cancellable_registry {
 	/// a thread that runs background IO if we are performing a resolve_continuous
 	std::shared_ptr<std::thread> background_io_;
 	/// the overall timeout for a query
-	lslboost::asio::steady_timer resolve_timeout_expired_;
+	asio::steady_timer resolve_timeout_expired_;
 	/// a timer that fires when a new wave should be scheduled
-	lslboost::asio::steady_timer wave_timer_;
+	asio::steady_timer wave_timer_;
 	/// a timer that fires when the unicast wave should be scheduled
-	lslboost::asio::steady_timer unicast_timer_;
+	asio::steady_timer unicast_timer_;
 };
 
 } // namespace lsl