Use namespace aliases instead of using lslboost::asio.

Author: tstenner

src/inlet_connection.cpp

@@ -4,7 +4,8 @@
 #include <sstream>
 
 using namespace lsl;
-using namespace lslboost::asio;
+namespace asio = lslboost::asio;
+namespace ip = asio::ip;
 
 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()),
@@ -110,7 +111,7 @@ ip::address resolve_v6_addr(const std::string &addr) {
 
 	// This more complicated procedure is required when the address is an ipv6 link-local address.
 	// Simplified from https://stackoverflow.com/a/10303761/73299
-	io_context io;
+	asio::io_context io;
 	auto res = ip::tcp::resolver(io).resolve(addr, "");
 	if (res.empty()) throw lost_error("Unable to resolve tcp stream at address: " + addr);
 	return res.begin()->endpoint().address();

src/resolve_attempt_udp.cpp

@@ -6,10 +6,10 @@
 #include <sstream>
 
 using namespace lsl;
-using namespace lslboost::asio;
+namespace asio = lslboost::asio;
 using err_t = const lslboost::system::error_code &;
 
-resolve_attempt_udp::resolve_attempt_udp(io_context &io, const udp &protocol,
+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),
@@ -28,14 +28,14 @@ resolve_attempt_udp::resolve_attempt_udp(io_context &io, const udp &protocol,
 	unicast_socket_.open(protocol);
 	try {
 		broadcast_socket_.open(protocol);
-		broadcast_socket_.set_option(socket_base::broadcast(true));
+		broadcast_socket_.set_option(asio::socket_base::broadcast(true));
 	} catch (std::exception &e) {
 		LOG_F(WARNING, "Cannot open UDP broadcast socket for resolves: %s", e.what());
 	}
 	try {
 		multicast_socket_.open(protocol);
 		multicast_socket_.set_option(
-			ip::multicast::hops(api_config::get_instance()->multicast_ttl()));
+			asio::ip::multicast::hops(api_config::get_instance()->multicast_ttl()));
 	} catch (std::exception &e) {
 		LOG_F(WARNING, "Cannot open UDP multicast socket for resolves: %s", e.what());
 	}
@@ -87,14 +87,14 @@ void resolve_attempt_udp::cancel() {
 // === receive loop ===
 
 void resolve_attempt_udp::receive_next_result() {
-	recv_socket_.async_receive_from(buffer(resultbuf_), remote_endpoint_,
+	recv_socket_.async_receive_from(asio::buffer(resultbuf_), remote_endpoint_,
 		[shared_this = shared_from_this()](
 			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) {
-	if (cancelled_ || err == error::operation_aborted || err == error::not_connected ||
-		err == error::not_socket)
+	if (cancelled_ || err == asio::error::operation_aborted || err == asio::error::not_connected ||
+		err == asio::error::not_socket)
 		return;
 
 	if (!err) {
@@ -150,14 +150,14 @@ void resolve_attempt_udp::send_next_query(endpoint_list::const_iterator next) {
 	if (ep.protocol() == recv_socket_.local_endpoint().protocol()) {
 		// select socket to use
 		udp::socket &sock =
-			(ep.address() == ip::address_v4::broadcast())
+			(ep.address() == asio::ip::address_v4::broadcast())
 				? 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,
 			[shared_this = shared_from_this(), next](err_t err, size_t) {
-				if (!shared_this->cancelled_ && err != error::operation_aborted &&
-					err != error::not_connected && err != error::not_socket)
+				if (!shared_this->cancelled_ && err != asio::error::operation_aborted &&
+					err != asio::error::not_connected && err != asio::error::not_socket)
 					shared_this->send_next_query(next);
 			});
 	} else

src/resolver_impl.cpp

@@ -10,12 +10,13 @@
 // === implementation of the resolver_impl class ===
 
 using namespace lsl;
-using namespace lslboost::asio;
+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),
-	  fast_mode_(true), io_(std::make_shared<io_context>()), resolve_timeout_expired_(*io_),
+	  fast_mode_(true), io_(std::make_shared<asio::io_context>()), resolve_timeout_expired_(*io_),
 	  wave_timer_(*io_), unicast_timer_(*io_) {
 	// parse the multicast addresses into endpoints and store them
 	uint16_t mcast_port = cfg_->multicast_port();
@@ -101,7 +102,7 @@ std::vector<stream_info_impl> resolver_impl::resolve_oneshot(
 	if (timeout != FOREVER) {
 		resolve_timeout_expired_.expires_after(timeout_sec(timeout));
 		resolve_timeout_expired_.async_wait([this](err_t err) {
-			if (err != error::operation_aborted) cancel_ongoing_resolve();
+			if (err != asio::error::operation_aborted) cancel_ongoing_resolve();
 		});
 	}
 
@@ -179,7 +180,7 @@ void resolver_impl::next_resolve_wave() {
 		}
 		wave_timer_.expires_after(timeout_sec(wave_timer_timeout));
 		wave_timer_.async_wait([this](err_t err) {
-			if (err != error::operation_aborted) next_resolve_wave();
+			if (err != asio::error::operation_aborted) next_resolve_wave();
 		});
 	}
 }
@@ -203,7 +204,7 @@ void resolver_impl::udp_multicast_burst() {
 }
 
 void resolver_impl::udp_unicast_burst(error_code err) {
-	if (err == error::operation_aborted) return;
+	if (err == asio::error::operation_aborted) return;
 
 	int failures = 0;
 	// start one per IP stack under consideration

src/socket_utils.cpp

@@ -3,8 +3,6 @@
 #include "common.h"
 #include <boost/endian/conversion.hpp>
 
-using namespace lsl;
-
 double lsl::measure_endian_performance() {
 	const double measure_duration = 0.01;
 	const double t_end = lsl_clock() + measure_duration;
@@ -17,7 +15,7 @@ double lsl::measure_endian_performance() {
 
 template <typename Socket, typename Protocol>
 uint16_t bind_port_in_range_(Socket &sock, Protocol protocol) {
-	const api_config *cfg = api_config::get_instance();
+	const auto *cfg = lsl::api_config::get_instance();
 	lslboost::system::error_code ec;
 	for (uint16_t port = cfg->base_port(), e = port + cfg->port_range(); port < e; port++) {
 		sock.bind(typename Protocol::endpoint(protocol, port), ec);
@@ -41,13 +39,14 @@ const std::string all_ports_bound_msg(
 	"https://labstreaminglayer.readthedocs.io/info/network-connectivity.html"
 	") or you have a problem with your network configuration.");
 
-uint16_t lsl::bind_port_in_range(udp::socket &acc, udp protocol) {
+uint16_t lsl::bind_port_in_range(asio::ip::udp::socket &acc, asio::ip::udp protocol) {
 	uint16_t port = bind_port_in_range_(acc, protocol);
 	if (!port) throw std::runtime_error(all_ports_bound_msg);
 	return port;
 }
 
-uint16_t lsl::bind_and_listen_to_port_in_range(tcp::acceptor &sock, tcp protocol, int backlog) {
+uint16_t lsl::bind_and_listen_to_port_in_range(
+	asio::ip::tcp::acceptor &sock, asio::ip::tcp protocol, int backlog) {
 	uint16_t port = bind_port_in_range_(sock, protocol);
 	if (!port) throw std::runtime_error(all_ports_bound_msg);
 	sock.listen(backlog);

src/socket_utils.h

@@ -4,18 +4,19 @@
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/asio/ip/udp.hpp>
 
-using namespace lslboost::asio::ip;
+namespace asio = lslboost::asio;
 
 namespace lsl {
-inline lslboost::asio::chrono::milliseconds timeout_sec(double timeout_seconds) {
-	return lslboost::asio::chrono::milliseconds(static_cast<unsigned int>(1000 * timeout_seconds));
+inline asio::chrono::milliseconds timeout_sec(double timeout_seconds) {
+	return asio::chrono::milliseconds(static_cast<unsigned int>(1000 * timeout_seconds));
 }
 
 /// Bind a socket to a free port in the configured port range or throw an error otherwise.
-uint16_t bind_port_in_range(udp::socket &sock, udp protocol);
+uint16_t bind_port_in_range(asio::ip::udp::socket &sock, asio::ip::udp protocol);
 
 /// Bind and listen to an acceptor on a free port in the configured port range or throw an error.
-uint16_t bind_and_listen_to_port_in_range(tcp::acceptor &acc, tcp protocol, int backlog);
+uint16_t bind_and_listen_to_port_in_range(
+	asio::ip::tcp::acceptor &acc, asio::ip::tcp protocol, int backlog);
 
 /// Measure the endian conversion performance of this machine.
 double measure_endian_performance();

src/stream_outlet_impl.cpp

@@ -7,7 +7,7 @@
 #include <memory>
 #include <sstream>
 
-using namespace lslboost::asio;
+namespace asio = lslboost::asio;
 
 namespace lsl {
 
@@ -69,17 +69,17 @@ void stream_outlet_impl::instantiate_stack(tcp tcp_protocol, udp udp_protocol) {
 	uint16_t multicast_port = cfg->multicast_port();
 	LOG_F(2, "%s: Trying to listen at address '%s'", info().name().c_str(), listen_address.c_str());
 	// create TCP data server
-	ios_.push_back(std::make_shared<io_context>());
+	ios_.push_back(std::make_shared<asio::io_context>());
 	tcp_servers_.push_back(std::make_shared<tcp_server>(
 		info_, ios_.back(), send_buffer_, sample_factory_, tcp_protocol, chunk_size_));
 	// create UDP time server
-	ios_.push_back(std::make_shared<io_context>());
+	ios_.push_back(std::make_shared<asio::io_context>());
 	udp_servers_.push_back(std::make_shared<udp_server>(info_, *ios_.back(), udp_protocol));
 	// create UDP multicast responders
 	for (const auto &mcastaddr : cfg->multicast_addresses()) {
 		try {
 			// use only addresses for the protocol that we're supposed to use here
-			ip::address address(ip::make_address(mcastaddr));
+			auto address = asio::ip::make_address(mcastaddr);
 			if (udp_protocol == udp::v4() ? address.is_v4() : address.is_v6())
 				responders_.push_back(std::make_shared<udp_server>(
 					info_, *ios_.back(), mcastaddr, multicast_port, multicast_ttl, listen_address));

src/tcp_server.cpp

@@ -23,7 +23,7 @@
 #define NO_EXPLICIT_TEMPLATE_INSTANTIATION
 #include "portable_archive/portable_oarchive.hpp"
 
-using namespace lslboost::asio;
+namespace asio = lslboost::asio;
 using err_t = const lslboost::system::error_code &;
 
 namespace lsl {
@@ -158,7 +158,7 @@ tcp_server::tcp_server(const stream_info_impl_p &info, const io_context_p &io,
 	info_->session_id(api_config::get_instance()->session_id());
 	info_->uid(lslboost::uuids::to_string(lslboost::uuids::random_generator()()));
 	info_->created_at(lsl_clock());
-	info_->hostname(ip::host_name());
+	info_->hostname(asio::ip::host_name());
 	if (protocol == tcp::v4())
 		info_->v4data_port(port);
 	else
@@ -200,7 +200,7 @@ void tcp_server::accept_next_connection() {
 			std::make_shared<client_session>(shared_from_this())};
 		// accept a connection on the session's socket
 		acceptor_->async_accept(
-			*newsession->socket(), [shared_this = shared_from_this(), newsession, this](err_t err) {
+			*newsession->socket(), [shared_this = shared_from_this(), newsession](err_t err) {
 				shared_this->handle_accept_outcome(newsession, err);
 			});
 	} catch (std::exception &e) {
@@ -209,7 +209,7 @@ void tcp_server::accept_next_connection() {
 }
 
 void tcp_server::handle_accept_outcome(std::shared_ptr<client_session> newsession, error_code err) {
-	if (err == error::operation_aborted || err == error::shut_down || shutdown_) return;
+	if (err == asio::error::operation_aborted || err == asio::error::shut_down || shutdown_) return;
 
 	// no error: start processing the new connection
 	if (!err) newsession->begin_processing();

src/time_receiver.cpp

@@ -9,7 +9,7 @@
 const double NOT_ASSIGNED = std::numeric_limits<double>::max();
 
 using namespace lsl;
-using namespace lslboost::asio;
+namespace asio = lslboost::asio;
 using err_t = const lslboost::system::error_code &;
 
 time_receiver::time_receiver(inlet_connection &conn)
@@ -113,7 +113,7 @@ void time_receiver::start_time_estimation() {
 	// schedule the next estimation step
 	next_estimate_.expires_after(timeout_sec(cfg_->time_update_interval()));
 	next_estimate_.async_wait([this](err_t err) {
-		if (err != error::operation_aborted) start_time_estimation();
+		if (err != asio::error::operation_aborted) start_time_estimation();
 	});
 }
 
@@ -170,7 +170,7 @@ void time_receiver::handle_receive_outcome(error_code err, std::size_t len) {
 	} catch (std::exception &e) {
 		LOG_F(WARNING, "Error while processing a time estimation return packet: %s", e.what());
 	}
-	if (err != error::operation_aborted) receive_next_packet();
+	if (err != asio::error::operation_aborted) receive_next_packet();
 }
 
 void time_receiver::result_aggregation_scheduled(error_code err) {