Use make_shared instead of new

Author: tstenner

src/resolver_impl.cpp

@@ -137,7 +137,7 @@ void resolver_impl::resolve_continuous(const std::string &query, double forget_a
 	// start a wave of resolve packets
 	next_resolve_wave();
 	// spawn a thread that runs the IO operations
-	background_io_.reset(new lslboost::thread(lslboost::bind(&io_context::run, io_)));
+	background_io_ = std::make_shared<lslboost::thread>(lslboost::bind(&io_context::run, io_));
 }
 
 std::vector<stream_info_impl> resolver_impl::results(uint32_t max_results) {
@@ -192,8 +192,9 @@ void resolver_impl::udp_multicast_burst() {
 	// start one per IP stack under consideration
 	for (std::size_t k = 0, failures = 0; k < udp_protocols_.size(); k++) {
 		try {
-			resolve_attempt_udp_p attempt(new resolve_attempt_udp(*io_, udp_protocols_[k],
-				mcast_endpoints_, query_, results_, results_mut_, cfg_->multicast_max_rtt(), this));
+			resolve_attempt_udp_p attempt(
+				std::make_shared<resolve_attempt_udp>(*io_, udp_protocols_[k], mcast_endpoints_,
+					query_, results_, results_mut_, cfg_->multicast_max_rtt(), this));
 			attempt->begin();
 		} catch (std::exception &e) {
 			if (++failures == udp_protocols_.size())

src/stream_outlet_impl.cpp

@@ -11,12 +11,12 @@ using namespace lslboost::asio;
 
 stream_outlet_impl::stream_outlet_impl(
 	const stream_info_impl &info, int chunk_size, int max_capacity)
-	: chunk_size_(chunk_size), info_(new stream_info_impl(info)),
-	  sample_factory_(new factory(info.channel_format(), info.channel_count(),
+	: chunk_size_(chunk_size), info_(std::make_shared<stream_info_impl>(info)),
+	  sample_factory_(std::make_shared<factory>(info.channel_format(), info.channel_count(),
 		  info.nominal_srate()
 			  ? info.nominal_srate() * api_config::get_instance()->outlet_buffer_reserve_ms() / 1000
 			  : api_config::get_instance()->outlet_buffer_reserve_samples())),
-	  send_buffer_(new send_buffer(max_capacity)) {
+	  send_buffer_(std::make_shared<send_buffer>(max_capacity)) {
 	ensure_lsl_initialized();
 	const api_config *cfg = api_config::get_instance();
 

src/tcp_server.cpp

@@ -151,7 +151,7 @@ class client_session : public std::enable_shared_from_this<client_session> {
 tcp_server::tcp_server(const stream_info_impl_p &info, const io_context_p &io,
 	const send_buffer_p &sendbuf, const factory_p &factory, tcp protocol, int chunk_size)
 	: chunk_size_(chunk_size), shutdown_(false), info_(info), io_(io), factory_(factory),
-	  send_buffer_(sendbuf), acceptor_(new tcp::acceptor(*io)) {
+	  send_buffer_(sendbuf), acceptor_(std::make_shared<tcp::acceptor>(*io)) {
 	// open the server connection
 	acceptor_->open(protocol);
 
@@ -338,7 +338,7 @@ void client_session::handle_read_query_outcome(error_code err) {
 }
 
 void client_session::send_status_message(const std::string &str) {
-	string_p msg(new std::string(str));
+	string_p msg(std::make_shared<std::string>(str));
 	async_write(*sock_, lslboost::asio::buffer(*msg),
 		lslboost::bind(
 			&client_session::handle_status_outcome, shared_from_this(), msg, placeholders::error));
@@ -504,7 +504,7 @@ void client_session::handle_send_feedheader_outcome(error_code err, std::size_t
 		if (!err) {
 			feedbuf_.consume(n);
 			// register outstanding work at the server (will be unregistered at session destruction)
-			work_.reset(new work_p::element_type(serv_->io_->get_executor()));
+			work_ = std::make_shared<work_p::element_type>(serv_->io_->get_executor());
 			// spawn a sample transfer thread
 			lslboost::thread(&client_session::transfer_samples_thread, this, shared_from_this());
 		}

src/udp_server.cpp

@@ -12,7 +12,8 @@ using namespace lsl;
 using namespace lslboost::asio;
 
 udp_server::udp_server(const stream_info_impl_p &info, io_context &io, udp protocol)
-	: info_(info), io_(io), socket_(new udp::socket(io)), time_services_enabled_(true) {
+	: info_(info), io_(io), socket_(std::make_shared<udp::socket>(io)),
+	  time_services_enabled_(true) {
 	// open the socket for the specified protocol
 	socket_->open(protocol);
 
@@ -29,7 +30,8 @@ udp_server::udp_server(const stream_info_impl_p &info, io_context &io, udp proto
 
 udp_server::udp_server(const stream_info_impl_p &info, io_context &io, const std::string &address,
 	uint16_t port, int ttl, const std::string &listen_address)
-	: info_(info), io_(io), socket_(new udp::socket(io)), time_services_enabled_(false) {
+	: info_(info), io_(io), socket_(std::make_shared<udp::socket>(io)),
+	  time_services_enabled_(false) {
 	ip::address addr = ip::make_address(address);
 	bool is_broadcast = addr == ip::address_v4::broadcast();
 
@@ -127,7 +129,8 @@ void udp_server::handle_receive_outcome(error_code err, std::size_t len) {
 					if (info_->matches_query(query)) {
 						// query matches: send back reply
 						udp::endpoint return_endpoint(remote_endpoint_.address(), return_port);
-						string_p replymsg(new std::string((query_id += "\r\n") += shortinfo_msg_));
+						string_p replymsg(
+							std::make_shared<std::string>((query_id += "\r\n") += shortinfo_msg_));
 						socket_->async_send_to(lslboost::asio::buffer(*replymsg), return_endpoint,
 							lslboost::bind(&udp_server::handle_send_outcome, shared_from_this(),
 								replymsg, placeholders::error));
@@ -147,7 +150,7 @@ void udp_server::handle_receive_outcome(error_code err, std::size_t len) {
 					std::ostringstream reply;
 					reply.precision(16);
 					reply << " " << wave_id << " " << t0 << " " << t1 << " " << lsl_clock();
-					string_p replymsg(new std::string(reply.str()));
+					string_p replymsg(std::make_shared<std::string>(reply.str()));
 					socket_->async_send_to(lslboost::asio::buffer(*replymsg), remote_endpoint_,
 						lslboost::bind(&udp_server::handle_send_outcome, shared_from_this(),
 							replymsg, placeholders::error));