diff options
Diffstat (limited to 'host')
156 files changed, 492 insertions, 505 deletions
diff --git a/host/examples/benchmark_streamer.cpp b/host/examples/benchmark_streamer.cpp index c2f3a4b2c..093d4254f 100644 --- a/host/examples/benchmark_streamer.cpp +++ b/host/examples/benchmark_streamer.cpp @@ -514,7 +514,7 @@ test_results benchmark_tx_streamer(uhd::device3::sptr usrp, const double duration, const std::string& format) { - std::vector<boost::shared_ptr<uhd::rfnoc::null_block_ctrl>> null_ctrls; + std::vector<std::shared_ptr<uhd::rfnoc::null_block_ctrl>> null_ctrls; for (const auto& id : null_ids) { null_ctrls.push_back(usrp->get_block_ctrl<uhd::rfnoc::null_block_ctrl>(id)); } diff --git a/host/examples/network_relay.cpp b/host/examples/network_relay.cpp index bf2ac9255..6de268aa9 100644 --- a/host/examples/network_relay.cpp +++ b/host/examples/network_relay.cpp @@ -22,7 +22,7 @@ namespace po = boost::program_options; namespace asio = boost::asio; -typedef boost::shared_ptr<asio::ip::udp::socket> socket_type; +typedef std::shared_ptr<asio::ip::udp::socket> socket_type; static const size_t insane_mtu = 9000; @@ -81,7 +81,7 @@ public: asio::ip::udp::resolver::query query(asio::ip::udp::v4(), server_addr, port); asio::ip::udp::endpoint endpoint = *resolver.resolve(query); - _server_socket = boost::shared_ptr<asio::ip::udp::socket>( + _server_socket = std::shared_ptr<asio::ip::udp::socket>( new asio::ip::udp::socket(_io_service, endpoint)); resize_buffs(_server_socket, server_rx_size, server_tx_size); } @@ -90,7 +90,7 @@ public: asio::ip::udp::resolver::query query(asio::ip::udp::v4(), client_addr, port); asio::ip::udp::endpoint endpoint = *resolver.resolve(query); - _client_socket = boost::shared_ptr<asio::ip::udp::socket>( + _client_socket = std::shared_ptr<asio::ip::udp::socket>( new asio::ip::udp::socket(_io_service)); _client_socket->open(asio::ip::udp::v4()); _client_socket->connect(endpoint); @@ -215,14 +215,14 @@ int UHD_SAFE_MAIN(int argc, char* argv[]) } { - boost::shared_ptr<udp_relay_type> ctrl(new udp_relay_type(bind, addr, "49152")); - boost::shared_ptr<udp_relay_type> rxdsp0(new udp_relay_type( + std::shared_ptr<udp_relay_type> ctrl(new udp_relay_type(bind, addr, "49152")); + std::shared_ptr<udp_relay_type> rxdsp0(new udp_relay_type( bind, addr, "49156", 0, tx_dsp_buff_size, rx_dsp_buff_size, 0)); - boost::shared_ptr<udp_relay_type> txdsp0(new udp_relay_type( + std::shared_ptr<udp_relay_type> txdsp0(new udp_relay_type( bind, addr, "49157", tx_dsp_buff_size, 0, 0, tx_dsp_buff_size)); - boost::shared_ptr<udp_relay_type> rxdsp1(new udp_relay_type( + std::shared_ptr<udp_relay_type> rxdsp1(new udp_relay_type( bind, addr, "49158", 0, tx_dsp_buff_size, rx_dsp_buff_size, 0)); - boost::shared_ptr<udp_relay_type> gps(new udp_relay_type(bind, addr, "49172")); + std::shared_ptr<udp_relay_type> gps(new udp_relay_type(bind, addr, "49172")); std::signal(SIGINT, &sig_int_handler); std::cout << "Press Ctrl + C to stop streaming..." << std::endl; diff --git a/host/examples/rfnoc_radio_loopback.cpp b/host/examples/rfnoc_radio_loopback.cpp index dffe30b3b..707c957e2 100644 --- a/host/examples/rfnoc_radio_loopback.cpp +++ b/host/examples/rfnoc_radio_loopback.cpp @@ -88,7 +88,7 @@ int UHD_SAFE_MAIN(int argc, char* argv[]) std::cout << std::endl; std::cout << boost::format("Creating the usrp device with: %s...") % args << std::endl; - auto dev = boost::dynamic_pointer_cast<uhd::device3>(uhd::device::make(args)); + auto dev = std::dynamic_pointer_cast<uhd::device3>(uhd::device::make(args)); if (not dev) { std::cout << "Error: Could not find an RFNoC-compatible device." << std::endl; return EXIT_FAILURE; diff --git a/host/examples/txrx_loopback_to_file.cpp b/host/examples/txrx_loopback_to_file.cpp index 271d249f6..6199ca429 100644 --- a/host/examples/txrx_loopback_to_file.cpp +++ b/host/examples/txrx_loopback_to_file.cpp @@ -117,10 +117,10 @@ void recv_to_file(uhd::usrp::multi_usrp::sptr usrp, // Create one ofstream object per channel // (use shared_ptr because ofstream is non-copyable) - std::vector<boost::shared_ptr<std::ofstream>> outfiles; + std::vector<std::shared_ptr<std::ofstream>> outfiles; for (size_t i = 0; i < buffs.size(); i++) { const std::string this_filename = generate_out_filename(file, buffs.size(), i); - outfiles.push_back(boost::shared_ptr<std::ofstream>( + outfiles.push_back(std::shared_ptr<std::ofstream>( new std::ofstream(this_filename.c_str(), std::ofstream::binary))); } UHD_ASSERT_THROW(outfiles.size() == buffs.size()); diff --git a/host/include/uhd/convert.hpp b/host/include/uhd/convert.hpp index 3af7cc47b..4d84fcdaa 100644 --- a/host/include/uhd/convert.hpp +++ b/host/include/uhd/convert.hpp @@ -12,7 +12,7 @@ #include <uhd/types/ref_vector.hpp> #include <boost/function.hpp> #include <boost/operators.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <string> namespace uhd { namespace convert { @@ -21,7 +21,7 @@ namespace uhd { namespace convert { class converter { public: - typedef boost::shared_ptr<converter> sptr; + typedef std::shared_ptr<converter> sptr; typedef uhd::ref_vector<void*> output_type; typedef uhd::ref_vector<const void*> input_type; diff --git a/host/include/uhd/device.hpp b/host/include/uhd/device.hpp index 44f74b210..11bedf216 100644 --- a/host/include/uhd/device.hpp +++ b/host/include/uhd/device.hpp @@ -14,7 +14,7 @@ #include <uhd/types/device_addr.hpp> #include <uhd/utils/noncopyable.hpp> #include <boost/function.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> namespace uhd { @@ -27,7 +27,7 @@ class property_tree; // forward declaration class UHD_API device : uhd::noncopyable { public: - typedef boost::shared_ptr<device> sptr; + typedef std::shared_ptr<device> sptr; typedef boost::function<device_addrs_t(const device_addr_t&)> find_t; typedef boost::function<sptr(const device_addr_t&)> make_t; diff --git a/host/include/uhd/property_tree.hpp b/host/include/uhd/property_tree.hpp index d97a5505e..4a839f8e9 100644 --- a/host/include/uhd/property_tree.hpp +++ b/host/include/uhd/property_tree.hpp @@ -12,10 +12,10 @@ #include <uhd/config.hpp> #include <uhd/utils/noncopyable.hpp> #include <boost/function.hpp> -#include <boost/shared_ptr.hpp> -#include <boost/utility.hpp> +#include <memory> #include <typeindex> #include <vector> +#include <string> namespace uhd { @@ -215,7 +215,7 @@ UHD_API fs_path operator/(const fs_path&, size_t); class UHD_API property_tree : uhd::noncopyable { public: - typedef boost::shared_ptr<property_tree> sptr; + typedef std::shared_ptr<property_tree> sptr; enum coerce_mode_t { AUTO_COERCE, MANUAL_COERCE }; @@ -246,21 +246,21 @@ public: //! Pop a property off the tree, and returns the property template <typename T> - boost::shared_ptr<property<T> > pop(const fs_path& path); + std::shared_ptr<property<T> > pop(const fs_path& path); private: //! Internal pop function - virtual boost::shared_ptr<void> _pop(const fs_path& path) = 0; + virtual std::shared_ptr<void> _pop(const fs_path& path) = 0; //! Internal create property with wild-card type - virtual void _create(const fs_path& path, const boost::shared_ptr<void>& prop, + virtual void _create(const fs_path& path, const std::shared_ptr<void>& prop, std::type_index prop_type) = 0; //! Internal access property with wild-card type - virtual boost::shared_ptr<void>& _access(const fs_path& path) const = 0; + virtual std::shared_ptr<void>& _access(const fs_path& path) const = 0; //! Internal access property with wild-card type but with type verification - virtual boost::shared_ptr<void>& _access_with_type_check( + virtual std::shared_ptr<void>& _access_with_type_check( const fs_path& path, std::type_index expected_prop_type) const = 0; }; diff --git a/host/include/uhd/property_tree.ipp b/host/include/uhd/property_tree.ipp index 20ad43fb1..3bae2a451 100644 --- a/host/include/uhd/property_tree.ipp +++ b/host/include/uhd/property_tree.ipp @@ -11,9 +11,9 @@ #include <uhd/exception.hpp> #include <boost/foreach.hpp> -#include <boost/scoped_ptr.hpp> #include <typeindex> #include <vector> +#include <memory> /*********************************************************************** * Implement templated property impl @@ -147,7 +147,7 @@ private: return value; } - static void init_or_set_value(boost::scoped_ptr<T>& scoped_value, const T& init_val) + static void init_or_set_value(std::unique_ptr<T>& scoped_value, const T& init_val) { if (scoped_value.get() == NULL) { scoped_value.reset(new T(init_val)); @@ -156,7 +156,7 @@ private: } } - static const T& get_value_ref(const boost::scoped_ptr<T>& scoped_value) + static const T& get_value_ref(const std::unique_ptr<T>& scoped_value) { if (scoped_value.get() == NULL) throw uhd::assertion_error("Cannot use uninitialized property data"); @@ -168,8 +168,8 @@ private: std::vector<typename property<T>::subscriber_type> _coerced_subscribers; typename property<T>::publisher_type _publisher; typename property<T>::coercer_type _coercer; - boost::scoped_ptr<T> _value; - boost::scoped_ptr<T> _coerced_value; + std::unique_ptr<T> _value; + std::unique_ptr<T> _coerced_value; }; }} // namespace uhd:: @@ -183,7 +183,7 @@ template <typename T> property<T>& property_tree::create(const fs_path& path, coerce_mode_t coerce_mode) { this->_create(path, - typename boost::shared_ptr<property<T> >(new property_impl<T>(coerce_mode)), + typename std::shared_ptr<property<T> >(new property_impl<T>(coerce_mode)), std::type_index(typeid(T))); return this->access<T>(path); } @@ -191,14 +191,14 @@ property<T>& property_tree::create(const fs_path& path, coerce_mode_t coerce_mod template <typename T> property<T>& property_tree::access(const fs_path& path) { - return *boost::static_pointer_cast<property<T> >( + return *std::static_pointer_cast<property<T> >( this->_access_with_type_check(path, std::type_index(typeid(T)))); } template <typename T> -typename boost::shared_ptr<property<T> > property_tree::pop(const fs_path& path) +typename std::shared_ptr<property<T> > property_tree::pop(const fs_path& path) { - return boost::static_pointer_cast<property<T> >(this->_pop(path)); + return std::static_pointer_cast<property<T> >(this->_pop(path)); } } // namespace uhd diff --git a/host/include/uhd/rfnoc/block_id.hpp b/host/include/uhd/rfnoc/block_id.hpp index 106fb394f..d15220aa7 100644 --- a/host/include/uhd/rfnoc/block_id.hpp +++ b/host/include/uhd/rfnoc/block_id.hpp @@ -10,7 +10,7 @@ #include <uhd/config.hpp> #include <stdint.h> -#include <boost/shared_ptr.hpp> +#include <memory> #include <iostream> #include <string> diff --git a/host/include/uhd/rfnoc/blockdef.hpp b/host/include/uhd/rfnoc/blockdef.hpp index e35c8e234..d6bcec414 100644 --- a/host/include/uhd/rfnoc/blockdef.hpp +++ b/host/include/uhd/rfnoc/blockdef.hpp @@ -11,18 +11,18 @@ #include <uhd/config.hpp> #include <uhd/types/device_addr.hpp> #include <stdint.h> -#include <boost/enable_shared_from_this.hpp> #include <set> #include <vector> +#include <memory> namespace uhd { namespace rfnoc { /*! Reads and stores block definitions for blocks and components. */ -class UHD_API blockdef : public boost::enable_shared_from_this<blockdef> +class UHD_API blockdef : public std::enable_shared_from_this<blockdef> { public: - typedef boost::shared_ptr<blockdef> sptr; + typedef std::shared_ptr<blockdef> sptr; //! Describes port options for a block definition. // diff --git a/host/include/uhd/stream.hpp b/host/include/uhd/stream.hpp index 7abab5b3c..5cbb652d6 100644 --- a/host/include/uhd/stream.hpp +++ b/host/include/uhd/stream.hpp @@ -14,7 +14,7 @@ #include <uhd/types/ref_vector.hpp> #include <uhd/types/stream_cmd.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/utility.hpp> #include <string> #include <vector> @@ -170,7 +170,7 @@ struct UHD_API stream_args_t class UHD_API rx_streamer : uhd::noncopyable { public: - typedef boost::shared_ptr<rx_streamer> sptr; + typedef std::shared_ptr<rx_streamer> sptr; virtual ~rx_streamer(void); @@ -248,7 +248,7 @@ public: class UHD_API tx_streamer : uhd::noncopyable { public: - typedef boost::shared_ptr<tx_streamer> sptr; + typedef std::shared_ptr<tx_streamer> sptr; virtual ~tx_streamer(void); diff --git a/host/include/uhd/transport/buffer_pool.hpp b/host/include/uhd/transport/buffer_pool.hpp index 53949cbaf..125d5b8e3 100644 --- a/host/include/uhd/transport/buffer_pool.hpp +++ b/host/include/uhd/transport/buffer_pool.hpp @@ -10,7 +10,7 @@ #include <uhd/config.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> namespace uhd { namespace transport { @@ -21,7 +21,7 @@ namespace uhd { namespace transport { class UHD_API buffer_pool : uhd::noncopyable { public: - typedef boost::shared_ptr<buffer_pool> sptr; + typedef std::shared_ptr<buffer_pool> sptr; typedef void* ptr_type; virtual ~buffer_pool(void) = 0; diff --git a/host/include/uhd/transport/muxed_zero_copy_if.hpp b/host/include/uhd/transport/muxed_zero_copy_if.hpp index d8230aaf9..61086fbba 100644 --- a/host/include/uhd/transport/muxed_zero_copy_if.hpp +++ b/host/include/uhd/transport/muxed_zero_copy_if.hpp @@ -28,7 +28,7 @@ namespace uhd { namespace transport { class muxed_zero_copy_if : private uhd::noncopyable { public: - typedef boost::shared_ptr<muxed_zero_copy_if> sptr; + typedef std::shared_ptr<muxed_zero_copy_if> sptr; /*! * Function to classify the stream based on the payload. diff --git a/host/include/uhd/transport/nirio/nifpga_lvbitx.h b/host/include/uhd/transport/nirio/nifpga_lvbitx.h index 1b27b67e0..a66e8fcc3 100644 --- a/host/include/uhd/transport/nirio/nifpga_lvbitx.h +++ b/host/include/uhd/transport/nirio/nifpga_lvbitx.h @@ -10,13 +10,12 @@ #include <uhd/transport/nirio/nirio_resource_manager.h> #include <uhd/transport/nirio/niriok_proxy.h> -#include <boost/smart_ptr.hpp> namespace uhd { namespace niusrprio { class UHD_API nifpga_lvbitx { public: - typedef boost::shared_ptr<nifpga_lvbitx> sptr; + typedef std::shared_ptr<nifpga_lvbitx> sptr; virtual ~nifpga_lvbitx() {}; diff --git a/host/include/uhd/transport/nirio/nirio_fifo.h b/host/include/uhd/transport/nirio/nirio_fifo.h index 317ca777d..405e6c41d 100644 --- a/host/include/uhd/transport/nirio/nirio_fifo.h +++ b/host/include/uhd/transport/nirio/nirio_fifo.h @@ -14,7 +14,6 @@ #include <uhd/transport/nirio/niriok_proxy.h> #include <uhd/transport/nirio/status.h> #include <uhd/utils/noncopyable.hpp> -#include <boost/smart_ptr.hpp> #include <boost/thread/recursive_mutex.hpp> #include <atomic> #include <string> @@ -34,7 +33,7 @@ template <typename data_t> class nirio_fifo : private uhd::noncopyable { public: - typedef boost::shared_ptr< nirio_fifo<data_t> > sptr; + typedef std::shared_ptr< nirio_fifo<data_t> > sptr; typedef enum { MINIMIZE_LATENCY, diff --git a/host/include/uhd/transport/nirio/nirio_resource_manager.h b/host/include/uhd/transport/nirio/nirio_resource_manager.h index de9c5f3fc..e1562419f 100644 --- a/host/include/uhd/transport/nirio/nirio_resource_manager.h +++ b/host/include/uhd/transport/nirio/nirio_resource_manager.h @@ -58,7 +58,7 @@ public: nirio_status get_register_offset(const char* register_name, uint32_t& offset); template<typename data_t> - nirio_status create_tx_fifo(const char* fifo_name, boost::shared_ptr< nirio_fifo<data_t> >& fifo) + nirio_status create_tx_fifo(const char* fifo_name, std::shared_ptr< nirio_fifo<data_t> >& fifo) { nirio_fifo_info_t* fifo_info_ptr = _lookup_fifo_info(fifo_name); if (fifo_info_ptr) { @@ -74,7 +74,7 @@ public: } template<typename data_t> - nirio_status create_rx_fifo(const char* fifo_name, boost::shared_ptr< nirio_fifo<data_t> >& fifo) + nirio_status create_rx_fifo(const char* fifo_name, std::shared_ptr< nirio_fifo<data_t> >& fifo) { nirio_fifo_info_t* fifo_info_ptr = _lookup_fifo_info(fifo_name); if (fifo_info_ptr) { diff --git a/host/include/uhd/transport/nirio/niriok_proxy.h b/host/include/uhd/transport/nirio/niriok_proxy.h index 8bd877e30..13cf172fa 100644 --- a/host/include/uhd/transport/nirio/niriok_proxy.h +++ b/host/include/uhd/transport/nirio/niriok_proxy.h @@ -8,13 +8,12 @@ #ifndef INCLUDED_UHD_TRANSPORT_NIRIO_NIRIO_INTERFACE_H #define INCLUDED_UHD_TRANSPORT_NIRIO_NIRIO_INTERFACE_H -#include <stdint.h> -#include <boost/smart_ptr.hpp> -#include <uhd/utils/noncopyable.hpp> -#include <boost/thread/shared_mutex.hpp> -#include <boost/thread/locks.hpp> #include <uhd/transport/nirio/nirio_driver_iface.h> #include <uhd/transport/nirio/nirio_quirks.h> +#include <uhd/utils/noncopyable.hpp> +#include <stdint.h> +#include <boost/thread/locks.hpp> +#include <boost/thread/shared_mutex.hpp> #define NI_VENDOR_NUM 0x1093 @@ -135,7 +134,7 @@ namespace uhd { namespace niusrprio class UHD_API niriok_proxy : public uhd::noncopyable { public: - typedef boost::shared_ptr<niriok_proxy> sptr; + typedef std::shared_ptr<niriok_proxy> sptr; static sptr make_and_open(const std::string& interface_path); diff --git a/host/include/uhd/transport/nirio/niriok_proxy_impl_v1.h b/host/include/uhd/transport/nirio/niriok_proxy_impl_v1.h index edeadc34d..b659cffab 100644 --- a/host/include/uhd/transport/nirio/niriok_proxy_impl_v1.h +++ b/host/include/uhd/transport/nirio/niriok_proxy_impl_v1.h @@ -8,7 +8,6 @@ #ifndef INCLUDED_UHD_TRANSPORT_NIRIO_NIRIO_PROXY_IMPL_V1_H #define INCLUDED_UHD_TRANSPORT_NIRIO_NIRIO_PROXY_IMPL_V1_H -#include <boost/smart_ptr.hpp> #include <uhd/utils/noncopyable.hpp> #include <uhd/transport/nirio/nirio_driver_iface.h> #include <uhd/transport/nirio/nirio_quirks.h> diff --git a/host/include/uhd/transport/nirio/niriok_proxy_impl_v2.h b/host/include/uhd/transport/nirio/niriok_proxy_impl_v2.h index 31013fbfc..0f49749de 100644 --- a/host/include/uhd/transport/nirio/niriok_proxy_impl_v2.h +++ b/host/include/uhd/transport/nirio/niriok_proxy_impl_v2.h @@ -8,7 +8,6 @@ #ifndef INCLUDED_UHD_TRANSPORT_NIRIO_NIRIO_PROXY_IMPL_V2_H #define INCLUDED_UHD_TRANSPORT_NIRIO_NIRIO_PROXY_IMPL_V2_H -#include <boost/smart_ptr.hpp> #include <uhd/utils/noncopyable.hpp> #include <uhd/transport/nirio/nirio_driver_iface.h> #include <uhd/transport/nirio/nirio_quirks.h> diff --git a/host/include/uhd/transport/nirio/niusrprio_session.h b/host/include/uhd/transport/nirio/niusrprio_session.h index 2154c41f1..2fff0ac36 100644 --- a/host/include/uhd/transport/nirio/niusrprio_session.h +++ b/host/include/uhd/transport/nirio/niusrprio_session.h @@ -15,7 +15,6 @@ #include <uhd/transport/nirio/rpc/usrprio_rpc_client.hpp> #include <uhd/utils/noncopyable.hpp> #include <stdint.h> -#include <boost/smart_ptr.hpp> #include <boost/thread/recursive_mutex.hpp> #include <string> @@ -24,7 +23,7 @@ namespace uhd { namespace niusrprio { class UHD_API niusrprio_session : private uhd::noncopyable { public: - typedef boost::shared_ptr<niusrprio_session> sptr; + typedef std::shared_ptr<niusrprio_session> sptr; typedef uhd::usrprio_rpc::usrprio_device_info device_info; typedef uhd::usrprio_rpc::usrprio_device_info_vtr device_info_vtr; @@ -42,7 +41,7 @@ public: template <typename data_t> nirio_status create_tx_fifo( - const char* fifo_name, boost::shared_ptr<nirio_fifo<data_t>>& fifo) + const char* fifo_name, std::shared_ptr<nirio_fifo<data_t>>& fifo) { if (!_session_open) return NiRio_Status_ResourceNotInitialized; @@ -51,7 +50,7 @@ public: template <typename data_t> nirio_status create_tx_fifo( - uint32_t fifo_instance, boost::shared_ptr<nirio_fifo<data_t>>& fifo) + uint32_t fifo_instance, std::shared_ptr<nirio_fifo<data_t>>& fifo) { if ((size_t)fifo_instance >= _lvbitx->get_output_fifo_count()) return NiRio_Status_InvalidParameter; @@ -60,7 +59,7 @@ public: template <typename data_t> nirio_status create_rx_fifo( - const char* fifo_name, boost::shared_ptr<nirio_fifo<data_t>>& fifo) + const char* fifo_name, std::shared_ptr<nirio_fifo<data_t>>& fifo) { if (!_session_open) return NiRio_Status_ResourceNotInitialized; @@ -69,7 +68,7 @@ public: template <typename data_t> nirio_status create_rx_fifo( - uint32_t fifo_instance, boost::shared_ptr<nirio_fifo<data_t>>& fifo) + uint32_t fifo_instance, std::shared_ptr<nirio_fifo<data_t>>& fifo) { if ((size_t)fifo_instance >= _lvbitx->get_input_fifo_count()) return NiRio_Status_InvalidParameter; diff --git a/host/include/uhd/transport/nirio/rpc/rpc_client.hpp b/host/include/uhd/transport/nirio/rpc/rpc_client.hpp index 80ba20320..04f560e6a 100644 --- a/host/include/uhd/transport/nirio/rpc/rpc_client.hpp +++ b/host/include/uhd/transport/nirio/rpc/rpc_client.hpp @@ -12,9 +12,9 @@ #include <uhd/utils/log.hpp> #include <uhd/utils/noncopyable.hpp> #include <boost/asio.hpp> -#include <boost/smart_ptr.hpp> #include <boost/thread/condition_variable.hpp> #include <boost/thread/thread.hpp> +#include <memory> namespace uhd { namespace usrprio_rpc { @@ -68,7 +68,7 @@ private: // Services boost::asio::io_service _io_service; - boost::scoped_ptr<boost::thread> _io_service_thread; + std::unique_ptr<boost::thread> _io_service_thread; boost::asio::ip::tcp::socket _socket; // Handshake info hshake_args_t _hshake_args_client; diff --git a/host/include/uhd/transport/nirio/rpc/rpc_common.hpp b/host/include/uhd/transport/nirio/rpc/rpc_common.hpp index 2384c0f61..9be1d024c 100644 --- a/host/include/uhd/transport/nirio/rpc/rpc_common.hpp +++ b/host/include/uhd/transport/nirio/rpc/rpc_common.hpp @@ -22,6 +22,7 @@ # include <boost/archive/text_oarchive.hpp> #endif #include <stdint.h> +#include <memory> namespace uhd { namespace usrprio_rpc { @@ -131,9 +132,9 @@ public: private: std::istringstream _stream; #if (USE_BINARY_ARCHIVE) - boost::scoped_ptr<boost::archive::binary_iarchive> _archive; + std::unique_ptr<boost::archive::binary_iarchive> _archive; #else - boost::scoped_ptr<boost::archive::text_iarchive> _archive; + std::unique_ptr<boost::archive::text_iarchive> _archive; #endif }; diff --git a/host/include/uhd/transport/nirio_zero_copy.hpp b/host/include/uhd/transport/nirio_zero_copy.hpp index b5e4dea38..096f592a8 100644 --- a/host/include/uhd/transport/nirio_zero_copy.hpp +++ b/host/include/uhd/transport/nirio_zero_copy.hpp @@ -13,14 +13,14 @@ #include <uhd/transport/zero_copy.hpp> #include <uhd/types/device_addr.hpp> #include <stdint.h> -#include <boost/shared_ptr.hpp> +#include <memory> namespace uhd { namespace transport { class UHD_API nirio_zero_copy : public virtual zero_copy_if { public: - typedef boost::shared_ptr<nirio_zero_copy> sptr; + typedef std::shared_ptr<nirio_zero_copy> sptr; static sptr make(uhd::niusrprio::niusrprio_session::sptr fpga_session, const uint32_t instance, diff --git a/host/include/uhd/transport/tcp_zero_copy.hpp b/host/include/uhd/transport/tcp_zero_copy.hpp index 4db68cec8..b1d052513 100644 --- a/host/include/uhd/transport/tcp_zero_copy.hpp +++ b/host/include/uhd/transport/tcp_zero_copy.hpp @@ -11,7 +11,7 @@ #include <uhd/config.hpp> #include <uhd/transport/zero_copy.hpp> #include <uhd/types/device_addr.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> namespace uhd { namespace transport { diff --git a/host/include/uhd/transport/udp_simple.hpp b/host/include/uhd/transport/udp_simple.hpp index a936cb204..52395d544 100644 --- a/host/include/uhd/transport/udp_simple.hpp +++ b/host/include/uhd/transport/udp_simple.hpp @@ -12,14 +12,14 @@ #include <uhd/types/serial.hpp> #include <uhd/utils/noncopyable.hpp> #include <boost/asio/buffer.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> namespace uhd { namespace transport { class UHD_API udp_simple : uhd::noncopyable { public: - typedef boost::shared_ptr<udp_simple> sptr; + typedef std::shared_ptr<udp_simple> sptr; virtual ~udp_simple(void) = 0; diff --git a/host/include/uhd/transport/udp_zero_copy.hpp b/host/include/uhd/transport/udp_zero_copy.hpp index 2fedad99a..3fb3fc396 100644 --- a/host/include/uhd/transport/udp_zero_copy.hpp +++ b/host/include/uhd/transport/udp_zero_copy.hpp @@ -11,7 +11,7 @@ #include <uhd/config.hpp> #include <uhd/transport/zero_copy.hpp> #include <uhd/types/device_addr.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> namespace uhd { namespace transport { @@ -34,7 +34,7 @@ public: size_t send_buff_size; }; - typedef boost::shared_ptr<udp_zero_copy> sptr; + typedef std::shared_ptr<udp_zero_copy> sptr; /*! * Make a new zero copy udp transport: diff --git a/host/include/uhd/transport/usb_control.hpp b/host/include/uhd/transport/usb_control.hpp index fb37dc9fe..a6ad1e1c9 100644 --- a/host/include/uhd/transport/usb_control.hpp +++ b/host/include/uhd/transport/usb_control.hpp @@ -10,14 +10,14 @@ #include <uhd/transport/usb_device_handle.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> namespace uhd { namespace transport { class UHD_API usb_control : uhd::noncopyable { public: - typedef boost::shared_ptr<usb_control> sptr; + typedef std::shared_ptr<usb_control> sptr; virtual ~usb_control(void); diff --git a/host/include/uhd/transport/usb_device_handle.hpp b/host/include/uhd/transport/usb_device_handle.hpp index a4eeae510..b0dea1b77 100644 --- a/host/include/uhd/transport/usb_device_handle.hpp +++ b/host/include/uhd/transport/usb_device_handle.hpp @@ -11,7 +11,7 @@ #include <uhd/config.hpp> #include <uhd/utils/noncopyable.hpp> #include <stdint.h> -#include <boost/shared_ptr.hpp> +#include <memory> #include <string> #include <vector> @@ -32,7 +32,7 @@ namespace uhd { namespace transport { class UHD_API usb_device_handle : uhd::noncopyable { public: - typedef boost::shared_ptr<usb_device_handle> sptr; + typedef std::shared_ptr<usb_device_handle> sptr; typedef std::pair<uint16_t, uint16_t> vid_pid_pair_t; virtual ~usb_device_handle(void); diff --git a/host/include/uhd/transport/usb_zero_copy.hpp b/host/include/uhd/transport/usb_zero_copy.hpp index d78807768..ecb3ff148 100644 --- a/host/include/uhd/transport/usb_zero_copy.hpp +++ b/host/include/uhd/transport/usb_zero_copy.hpp @@ -27,7 +27,7 @@ namespace uhd { namespace transport { class UHD_API usb_zero_copy : public virtual zero_copy_if { public: - typedef boost::shared_ptr<usb_zero_copy> sptr; + typedef std::shared_ptr<usb_zero_copy> sptr; virtual ~usb_zero_copy(void); diff --git a/host/include/uhd/transport/zero_copy.hpp b/host/include/uhd/transport/zero_copy.hpp index c59213e92..a28398445 100644 --- a/host/include/uhd/transport/zero_copy.hpp +++ b/host/include/uhd/transport/zero_copy.hpp @@ -12,7 +12,7 @@ #include <uhd/utils/noncopyable.hpp> #include <boost/detail/atomic_count.hpp> #include <boost/intrusive_ptr.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/utility.hpp> namespace uhd { namespace transport { @@ -148,7 +148,7 @@ struct zero_copy_xport_params class UHD_API zero_copy_if : uhd::noncopyable { public: - typedef boost::shared_ptr<zero_copy_if> sptr; + typedef std::shared_ptr<zero_copy_if> sptr; /*! * Clean up tasks before releasing the transport object. diff --git a/host/include/uhd/transport/zero_copy_flow_ctrl.hpp b/host/include/uhd/transport/zero_copy_flow_ctrl.hpp index f98a0891c..f12aed2a9 100644 --- a/host/include/uhd/transport/zero_copy_flow_ctrl.hpp +++ b/host/include/uhd/transport/zero_copy_flow_ctrl.hpp @@ -11,7 +11,7 @@ #include <uhd/config.hpp> #include <uhd/transport/zero_copy.hpp> #include <boost/function.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> namespace uhd { namespace transport { @@ -28,7 +28,7 @@ typedef boost::function<bool(managed_buffer::sptr buff)> flow_ctrl_func; class UHD_API zero_copy_flow_ctrl : public virtual zero_copy_if { public: - typedef boost::shared_ptr<zero_copy_flow_ctrl> sptr; + typedef std::shared_ptr<zero_copy_flow_ctrl> sptr; /*! * Make flow controlled transport. diff --git a/host/include/uhd/types/filters.hpp b/host/include/uhd/types/filters.hpp index ff72dd5e3..d15002c0e 100644 --- a/host/include/uhd/types/filters.hpp +++ b/host/include/uhd/types/filters.hpp @@ -12,7 +12,7 @@ #include <uhd/utils/log.hpp> #include <stdint.h> #include <boost/scoped_array.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <iostream> #include <ostream> #include <sstream> @@ -24,7 +24,7 @@ namespace uhd { class UHD_API filter_info_base { public: - typedef boost::shared_ptr<filter_info_base> sptr; + typedef std::shared_ptr<filter_info_base> sptr; enum filter_type { ANALOG_LOW_PASS, ANALOG_BAND_PASS, DIGITAL_I16, DIGITAL_FIR_I16 }; filter_info_base(filter_type type, bool bypass, size_t position_index) @@ -63,7 +63,7 @@ class UHD_API analog_filter_base : public filter_info_base std::string _analog_type; public: - typedef boost::shared_ptr<analog_filter_base> sptr; + typedef std::shared_ptr<analog_filter_base> sptr; analog_filter_base(filter_type type, bool bypass, size_t position_index, @@ -87,7 +87,7 @@ class UHD_API analog_filter_lp : public analog_filter_base double _rolloff; public: - typedef boost::shared_ptr<analog_filter_lp> sptr; + typedef std::shared_ptr<analog_filter_lp> sptr; analog_filter_lp(filter_type type, bool bypass, size_t position_index, @@ -130,7 +130,7 @@ protected: std::vector<tap_t> _taps; public: - typedef boost::shared_ptr<digital_filter_base> sptr; + typedef std::shared_ptr<digital_filter_base> sptr; digital_filter_base(filter_type type, bool bypass, size_t position_index, @@ -208,7 +208,7 @@ template <typename tap_t> class UHD_API digital_filter_fir : public digital_filter_base<tap_t> { public: - typedef boost::shared_ptr<digital_filter_fir<tap_t> > sptr; + typedef std::shared_ptr<digital_filter_fir<tap_t> > sptr; digital_filter_fir(filter_info_base::filter_type type, bool bypass, diff --git a/host/include/uhd/types/serial.hpp b/host/include/uhd/types/serial.hpp index 82d2f6070..a34baf5eb 100644 --- a/host/include/uhd/types/serial.hpp +++ b/host/include/uhd/types/serial.hpp @@ -10,7 +10,7 @@ #include <uhd/config.hpp> #include <stdint.h> -#include <boost/shared_ptr.hpp> +#include <memory> #include <string> #include <vector> @@ -36,7 +36,7 @@ typedef std::vector<uint8_t> byte_vector_t; class UHD_API i2c_iface { public: - typedef boost::shared_ptr<i2c_iface> sptr; + typedef std::shared_ptr<i2c_iface> sptr; virtual ~i2c_iface(void); @@ -115,7 +115,7 @@ struct UHD_API spi_config_t class UHD_API spi_iface { public: - typedef boost::shared_ptr<spi_iface> sptr; + typedef std::shared_ptr<spi_iface> sptr; virtual ~spi_iface(void); @@ -162,7 +162,7 @@ public: class UHD_API uart_iface { public: - typedef boost::shared_ptr<uart_iface> sptr; + typedef std::shared_ptr<uart_iface> sptr; virtual ~uart_iface(void); diff --git a/host/include/uhd/types/wb_iface.hpp b/host/include/uhd/types/wb_iface.hpp index 495762118..2b7a6d4c5 100644 --- a/host/include/uhd/types/wb_iface.hpp +++ b/host/include/uhd/types/wb_iface.hpp @@ -11,14 +11,14 @@ #include <uhd/config.hpp> #include <uhd/types/time_spec.hpp> #include <stdint.h> -#include <boost/shared_ptr.hpp> +#include <memory> namespace uhd { class UHD_API wb_iface { public: - typedef boost::shared_ptr<wb_iface> sptr; + typedef std::shared_ptr<wb_iface> sptr; typedef uint32_t wb_addr_type; virtual ~wb_iface(void); @@ -69,7 +69,7 @@ public: class UHD_API timed_wb_iface : public wb_iface { public: - typedef boost::shared_ptr<timed_wb_iface> sptr; + typedef std::shared_ptr<timed_wb_iface> sptr; /*! * Get the command time. diff --git a/host/include/uhd/usrp/dboard_base.hpp b/host/include/uhd/usrp/dboard_base.hpp index 25f5b816d..9575e6bc9 100644 --- a/host/include/uhd/usrp/dboard_base.hpp +++ b/host/include/uhd/usrp/dboard_base.hpp @@ -13,7 +13,7 @@ #include <uhd/usrp/dboard_id.hpp> #include <uhd/usrp/dboard_iface.hpp> #include <uhd/utils/pimpl.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/utils/noncopyable.hpp> namespace uhd { namespace usrp { @@ -25,7 +25,7 @@ namespace uhd { namespace usrp { class UHD_API dboard_base : uhd::noncopyable { public: - typedef boost::shared_ptr<dboard_base> sptr; + typedef std::shared_ptr<dboard_base> sptr; /*! * An opaque type for the dboard constructor args. * Derived classes should pass the args into the base class, diff --git a/host/include/uhd/usrp/dboard_iface.hpp b/host/include/uhd/usrp/dboard_iface.hpp index 162d0c6a3..9a25fb607 100644 --- a/host/include/uhd/usrp/dboard_iface.hpp +++ b/host/include/uhd/usrp/dboard_iface.hpp @@ -15,7 +15,7 @@ #include <uhd/usrp/gpio_defs.hpp> #include <uhd/utils/pimpl.hpp> #include <stdint.h> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/thread/thread.hpp> #include <string> #include <vector> @@ -53,7 +53,7 @@ struct UHD_API dboard_iface_special_props_t class UHD_API dboard_iface : public uhd::i2c_iface { public: - typedef boost::shared_ptr<dboard_iface> sptr; + typedef std::shared_ptr<dboard_iface> sptr; typedef dboard_iface_special_props_t special_props_t; //! tells the host which unit to use diff --git a/host/include/uhd/usrp/dboard_manager.hpp b/host/include/uhd/usrp/dboard_manager.hpp index eb255c346..737c24add 100644 --- a/host/include/uhd/usrp/dboard_manager.hpp +++ b/host/include/uhd/usrp/dboard_manager.hpp @@ -12,7 +12,7 @@ #include <uhd/usrp/dboard_base.hpp> #include <uhd/usrp/dboard_eeprom.hpp> #include <uhd/usrp/dboard_id.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/utils/noncopyable.hpp> #include <string> #include <vector> @@ -27,7 +27,7 @@ namespace uhd { namespace usrp { class UHD_API dboard_manager : uhd::noncopyable { public: - typedef boost::shared_ptr<dboard_manager> sptr; + typedef std::shared_ptr<dboard_manager> sptr; // dboard constructor (each dboard should have a ::make with this signature) typedef dboard_base::sptr (*dboard_ctor_t)(dboard_base::ctor_args_t); diff --git a/host/include/uhd/usrp/gps_ctrl.hpp b/host/include/uhd/usrp/gps_ctrl.hpp index a3485226c..7743894c1 100644 --- a/host/include/uhd/usrp/gps_ctrl.hpp +++ b/host/include/uhd/usrp/gps_ctrl.hpp @@ -11,7 +11,7 @@ #include <uhd/types/sensors.hpp> #include <uhd/types/serial.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <vector> namespace uhd { @@ -19,7 +19,7 @@ namespace uhd { class UHD_API gps_ctrl : uhd::noncopyable { public: - typedef boost::shared_ptr<gps_ctrl> sptr; + typedef std::shared_ptr<gps_ctrl> sptr; virtual ~gps_ctrl(void) = 0; diff --git a/host/include/uhd/usrp/multi_usrp.hpp b/host/include/uhd/usrp/multi_usrp.hpp index 99a966b7a..27b5f3d9a 100644 --- a/host/include/uhd/usrp/multi_usrp.hpp +++ b/host/include/uhd/usrp/multi_usrp.hpp @@ -35,7 +35,7 @@ #include <uhd/types/wb_iface.hpp> #include <uhd/usrp/dboard_iface.hpp> #include <uhd/usrp/subdev_spec.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/utils/noncopyable.hpp> #include <complex> #include <string> @@ -95,7 +95,7 @@ namespace usrp { class UHD_API multi_usrp : uhd::noncopyable { public: - typedef boost::shared_ptr<multi_usrp> sptr; + typedef std::shared_ptr<multi_usrp> sptr; virtual ~multi_usrp(void) = 0; diff --git a/host/include/uhd/usrp_clock/multi_usrp_clock.hpp b/host/include/uhd/usrp_clock/multi_usrp_clock.hpp index 48f8a5eae..6faa10714 100644 --- a/host/include/uhd/usrp_clock/multi_usrp_clock.hpp +++ b/host/include/uhd/usrp_clock/multi_usrp_clock.hpp @@ -45,7 +45,7 @@ namespace uhd { namespace usrp_clock { class UHD_API multi_usrp_clock : uhd::noncopyable { public: - typedef boost::shared_ptr<multi_usrp_clock> sptr; + typedef std::shared_ptr<multi_usrp_clock> sptr; virtual ~multi_usrp_clock(void) = 0; diff --git a/host/include/uhd/utils/gain_group.hpp b/host/include/uhd/utils/gain_group.hpp index 69cd9dc6b..8fe69441f 100644 --- a/host/include/uhd/utils/gain_group.hpp +++ b/host/include/uhd/utils/gain_group.hpp @@ -12,7 +12,7 @@ #include <uhd/types/ranges.hpp> #include <uhd/utils/noncopyable.hpp> #include <boost/function.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <string> #include <vector> @@ -31,7 +31,7 @@ struct UHD_API gain_fcns_t class UHD_API gain_group : uhd::noncopyable { public: - typedef boost::shared_ptr<gain_group> sptr; + typedef std::shared_ptr<gain_group> sptr; virtual ~gain_group(void) = 0; diff --git a/host/include/uhd/utils/msg_task.hpp b/host/include/uhd/utils/msg_task.hpp index 4e73b7720..fd08523f7 100644 --- a/host/include/uhd/utils/msg_task.hpp +++ b/host/include/uhd/utils/msg_task.hpp @@ -13,7 +13,7 @@ #include <stdint.h> #include <boost/function.hpp> #include <boost/optional/optional.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/utils/noncopyable.hpp> #include <vector> @@ -21,7 +21,7 @@ namespace uhd { class UHD_API msg_task : uhd::noncopyable { public: - typedef boost::shared_ptr<msg_task> sptr; + typedef std::shared_ptr<msg_task> sptr; typedef std::vector<uint8_t> msg_payload_t; typedef std::pair<uint32_t, msg_payload_t> msg_type_t; typedef boost::function<boost::optional<msg_type_t>(void)> task_fcn_type; diff --git a/host/include/uhd/utils/pimpl.hpp b/host/include/uhd/utils/pimpl.hpp index a19f4ddc2..b0fbf7fec 100644 --- a/host/include/uhd/utils/pimpl.hpp +++ b/host/include/uhd/utils/pimpl.hpp @@ -9,7 +9,7 @@ #define INCLUDED_UHD_UTILS_PIMPL_HPP #include <uhd/config.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> /*! \file pimpl.hpp * "Pimpl idiom" (pointer to implementation idiom). @@ -31,7 +31,7 @@ */ #define UHD_PIMPL_DECL(_name) \ struct _name; \ - boost::shared_ptr<_name> + std::shared_ptr<_name> /*! * Make an instance of a pimpl in a source file. @@ -40,6 +40,6 @@ * \param _name the name of the pimpl class * \param _args the constructor args for the pimpl */ -#define UHD_PIMPL_MAKE(_name, _args) boost::shared_ptr<_name>(new _name _args) +#define UHD_PIMPL_MAKE(_name, _args) std::shared_ptr<_name>(new _name _args) #endif /* INCLUDED_UHD_UTILS_PIMPL_HPP */ diff --git a/host/include/uhd/utils/soft_register.hpp b/host/include/uhd/utils/soft_register.hpp index b6897551f..ba716b206 100644 --- a/host/include/uhd/utils/soft_register.hpp +++ b/host/include/uhd/utils/soft_register.hpp @@ -138,7 +138,7 @@ template <typename reg_data_t, bool readable, bool writable> class UHD_API soft_register_t : public soft_register_base { public: - typedef boost::shared_ptr<soft_register_t<reg_data_t, readable, writable> > sptr; + typedef std::shared_ptr<soft_register_t<reg_data_t, readable, writable> > sptr; // Reserved field. Represents all bits in the register. UHD_DEFINE_SOFT_REG_FIELD(REGISTER, sizeof(reg_data_t) * 8, 0); //[WIDTH-1:0] @@ -312,7 +312,7 @@ class UHD_API soft_register_sync_t : public soft_register_t<reg_data_t, readable, writable> { public: - typedef boost::shared_ptr<soft_register_sync_t<reg_data_t, readable, writable> > sptr; + typedef std::shared_ptr<soft_register_sync_t<reg_data_t, readable, writable> > sptr; soft_register_sync_t(wb_iface::wb_addr_type wr_addr, wb_iface::wb_addr_type rd_addr, @@ -428,7 +428,7 @@ typedef soft_register_sync_t<uint64_t, true, true> soft_reg64_rw_sync_t; reg_obj.initialize(iface); reg_obj.write(example_reg_t::FIELD2, 0x1234); - example_reg_t::sptr reg_sptr = boost::make_shared<example_reg_t>(); + example_reg_t::sptr reg_sptr = std::make_shared<example_reg_t>(); reg_obj->initialize(iface); reg_obj->write(example_reg_t::FIELD2, 0x1234); } @@ -444,7 +444,7 @@ namespace uhd { class UHD_API soft_regmap_accessor_t { public: - typedef boost::shared_ptr<soft_regmap_accessor_t> sptr; + typedef std::shared_ptr<soft_regmap_accessor_t> sptr; virtual ~soft_regmap_accessor_t(){}; virtual soft_register_base& lookup(const std::string& path) const = 0; @@ -587,7 +587,7 @@ private: class UHD_API soft_regmap_db_t : public soft_regmap_accessor_t, public uhd::noncopyable { public: - typedef boost::shared_ptr<soft_regmap_db_t> sptr; + typedef std::shared_ptr<soft_regmap_db_t> sptr; /*! * Use the default constructor if this is the top-level DB diff --git a/host/include/uhd/utils/tasks.hpp b/host/include/uhd/utils/tasks.hpp index fdb3869ee..eaee3edbe 100644 --- a/host/include/uhd/utils/tasks.hpp +++ b/host/include/uhd/utils/tasks.hpp @@ -1,7 +1,8 @@ // // Copyright 2011-2012 Ettus Research LLC -// Copyright 2018 Ettus Research, a National Instruments Company // Copyright 2017 Ettus Research (National Instruments Corp.) +// Copyright 2018 Ettus Research, a National Instruments Company +// Copyright 2019 Ettus Research, a National Instruments Brand // // SPDX-License-Identifier: GPL-3.0-or-later // @@ -12,15 +13,15 @@ #include <uhd/config.hpp> #include <uhd/utils/noncopyable.hpp> #include <boost/function.hpp> -#include <boost/shared_ptr.hpp> -#include <boost/utility.hpp> +#include <memory> +#include <string> namespace uhd { class UHD_API task : uhd::noncopyable { public: - typedef boost::shared_ptr<task> sptr; + typedef std::shared_ptr<task> sptr; typedef boost::function<void(void)> task_fcn_type; /*! diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/unpack.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/unpack.hpp index 4e00453c8..c407a0967 100644 --- a/host/lib/deps/rpclib/include/rpc/msgpack/unpack.hpp +++ b/host/lib/deps/rpclib/include/rpc/msgpack/unpack.hpp @@ -1050,8 +1050,8 @@ public: // std::auto_ptr<msgpack:zone> z = result.zone(); // on_message(obj, z); // - // //// boost::shared_ptr is also usable: - // // boost::shared_ptr<zone> life(z.release()); + // //// std::shared_ptr is also usable: + // // std::shared_ptr<zone> life(z.release()); // // on_message(result.get(), life); // } // diff --git a/host/lib/device.cpp b/host/lib/device.cpp index d2d98718e..c17713bbd 100644 --- a/host/lib/device.cpp +++ b/host/lib/device.cpp @@ -15,12 +15,12 @@ #include <uhdlib/utils/prefs.hpp> #include <boost/format.hpp> -#include <boost/weak_ptr.hpp> #include <boost/functional/hash.hpp> #include <boost/tuple/tuple.hpp> #include <boost/thread/mutex.hpp> #include <future> +#include <memory> using namespace uhd; @@ -172,7 +172,7 @@ device::sptr device::make(const device_addr_t &hint, device_filter_t filter, siz } //map device address hash to created devices - static uhd::dict<size_t, boost::weak_ptr<device> > hash_to_device; + static uhd::dict<size_t, std::weak_ptr<device> > hash_to_device; //try to find an existing device if (hash_to_device.has_key(dev_hash) and not hash_to_device[dev_hash].expired()){ diff --git a/host/lib/experts/expert_container.cpp b/host/lib/experts/expert_container.cpp index 1cdc7841b..33412cb6f 100644 --- a/host/lib/experts/expert_container.cpp +++ b/host/lib/experts/expert_container.cpp @@ -5,20 +5,19 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <uhdlib/experts/expert_container.hpp> #include <uhd/exception.hpp> #include <uhd/utils/log.hpp> +#include <uhdlib/experts/expert_container.hpp> +#include <boost/bind.hpp> #include <boost/format.hpp> #include <boost/function.hpp> -#include <boost/bind.hpp> -#include <boost/make_shared.hpp> -#include <boost/scoped_ptr.hpp> -#include <boost/thread/mutex.hpp> -#include <boost/thread.hpp> -#include <boost/graph/graph_traits.hpp> +#include <boost/graph/adjacency_list.hpp> #include <boost/graph/depth_first_search.hpp> +#include <boost/graph/graph_traits.hpp> #include <boost/graph/topological_sort.hpp> -#include <boost/graph/adjacency_list.hpp> +#include <boost/thread.hpp> +#include <boost/thread/mutex.hpp> +#include <memory> #ifdef UHD_EXPERT_LOGGING #define EX_LOG(depth, str) _log(depth, str) @@ -517,7 +516,7 @@ private: expert_container::sptr expert_container::make(const std::string& name) { - return boost::make_shared<expert_container_impl>(name); + return std::make_shared<expert_container_impl>(name); } }} diff --git a/host/lib/include/uhdlib/experts/expert_container.hpp b/host/lib/include/uhdlib/experts/expert_container.hpp index 5c8df5f1a..da52f6f4a 100644 --- a/host/lib/include/uhdlib/experts/expert_container.hpp +++ b/host/lib/include/uhdlib/experts/expert_container.hpp @@ -11,7 +11,7 @@ #include <uhdlib/experts/expert_nodes.hpp> #include <uhd/config.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/thread/recursive_mutex.hpp> namespace uhd { namespace experts { @@ -25,7 +25,7 @@ namespace uhd { namespace experts { class UHD_API expert_container : private uhd::noncopyable, public node_retriever_t { public: //Methods - typedef boost::shared_ptr<expert_container> sptr; + typedef std::shared_ptr<expert_container> sptr; virtual ~expert_container() {}; diff --git a/host/lib/include/uhdlib/rfnoc/reg_iface_adapter.hpp b/host/lib/include/uhdlib/rfnoc/reg_iface_adapter.hpp index 55153c229..9a5dd39f4 100644 --- a/host/lib/include/uhdlib/rfnoc/reg_iface_adapter.hpp +++ b/host/lib/include/uhdlib/rfnoc/reg_iface_adapter.hpp @@ -10,11 +10,11 @@ #include <uhd/config.hpp> #include <uhd/rfnoc/register_iface.hpp> #include <uhd/types/wb_iface.hpp> -#include <boost/make_shared.hpp> +#include <memory> //! Convenience macro to generate a reg_iface_adapter from within an RFNoC block #define RFNOC_MAKE_WB_IFACE(BASE_OFFSET, CHAN) \ - boost::make_shared<reg_iface_adapter>( \ + std::make_shared<reg_iface_adapter>( \ [this]() -> register_iface& { return regs(); }, \ [this, chan = CHAN]() { return get_command_time(chan); }, \ [this, chan = CHAN]( \ @@ -28,7 +28,7 @@ namespace uhd { namespace rfnoc { * From within a noc_block_base derivative, this call will work to create a * wb_iface: * - * wb_iface::sptr ctrl = boost::make_shared<reg_iface_adapter>( + * wb_iface::sptr ctrl = std::make_shared<reg_iface_adapter>( * [this]() -> register_iface& { return regs(); }, offset); * * Or you use the macro: diff --git a/host/lib/include/uhdlib/rfnoc/rfnoc_device.hpp b/host/lib/include/uhdlib/rfnoc/rfnoc_device.hpp index cbb9aa120..42872ba43 100644 --- a/host/lib/include/uhdlib/rfnoc/rfnoc_device.hpp +++ b/host/lib/include/uhdlib/rfnoc/rfnoc_device.hpp @@ -12,7 +12,7 @@ #include <uhd/rfnoc/mb_controller.hpp> #include <uhdlib/rfnoc/client_zero.hpp> #include <uhdlib/rfnoc/mb_iface.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> namespace uhd { namespace rfnoc { namespace detail { @@ -21,7 +21,7 @@ namespace uhd { namespace rfnoc { namespace detail { class rfnoc_device : public uhd::device { public: - using sptr = boost::shared_ptr<rfnoc_device>; // FIXME make std::shared_ptr when + using sptr = std::shared_ptr<rfnoc_device>; // FIXME make std::shared_ptr when // uhd::device is ready rfnoc_device() diff --git a/host/lib/include/uhdlib/transport/dpdk_zero_copy.hpp b/host/lib/include/uhdlib/transport/dpdk_zero_copy.hpp index 8dcce6eee..3497f0598 100644 --- a/host/lib/include/uhdlib/transport/dpdk_zero_copy.hpp +++ b/host/lib/include/uhdlib/transport/dpdk_zero_copy.hpp @@ -10,7 +10,7 @@ #include <uhdlib/transport/dpdk_common.hpp> #include <uhd/types/device_addr.hpp> #include <uhd/transport/zero_copy.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <string> @@ -21,7 +21,7 @@ namespace uhd { namespace transport { */ class dpdk_zero_copy : public virtual zero_copy_if { public: - typedef boost::shared_ptr<dpdk_zero_copy> sptr; + typedef std::shared_ptr<dpdk_zero_copy> sptr; static sptr make( const struct uhd_dpdk_ctx &ctx, diff --git a/host/lib/include/uhdlib/usrp/common/ad9361_ctrl.hpp b/host/lib/include/uhdlib/usrp/common/ad9361_ctrl.hpp index 99d74d80f..955da7c62 100644 --- a/host/lib/include/uhdlib/usrp/common/ad9361_ctrl.hpp +++ b/host/lib/include/uhdlib/usrp/common/ad9361_ctrl.hpp @@ -13,7 +13,7 @@ #include <uhd/types/serial.hpp> #include <uhd/types/sensors.hpp> #include <uhd/exception.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <ad9361_device.h> #include <string> #include <complex> @@ -40,7 +40,7 @@ namespace uhd { namespace usrp { class ad9361_ctrl : public uhd::noncopyable { public: - typedef boost::shared_ptr<ad9361_ctrl> sptr; + typedef std::shared_ptr<ad9361_ctrl> sptr; virtual ~ad9361_ctrl(void) {} diff --git a/host/lib/include/uhdlib/usrp/common/ad936x_manager.hpp b/host/lib/include/uhdlib/usrp/common/ad936x_manager.hpp index 7abbe69ed..2d21d55e7 100644 --- a/host/lib/include/uhdlib/usrp/common/ad936x_manager.hpp +++ b/host/lib/include/uhdlib/usrp/common/ad936x_manager.hpp @@ -14,7 +14,7 @@ #include <uhd/types/direction.hpp> #include <uhdlib/usrp/common/ad9361_ctrl.hpp> #include <boost/format.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <stdint.h> #include <functional> @@ -29,7 +29,7 @@ namespace uhd { namespace usrp { class ad936x_manager { public: - typedef boost::shared_ptr<ad936x_manager> sptr; + typedef std::shared_ptr<ad936x_manager> sptr; static const double DEFAULT_GAIN; static const double DEFAULT_BANDWIDTH; diff --git a/host/lib/include/uhdlib/usrp/common/adf435x.hpp b/host/lib/include/uhdlib/usrp/common/adf435x.hpp index 056290451..6f654bcbb 100644 --- a/host/lib/include/uhdlib/usrp/common/adf435x.hpp +++ b/host/lib/include/uhdlib/usrp/common/adf435x.hpp @@ -23,7 +23,7 @@ class adf435x_iface { public: - typedef boost::shared_ptr<adf435x_iface> sptr; + typedef std::shared_ptr<adf435x_iface> sptr; typedef boost::function<void(std::vector<uint32_t>)> write_fn_t; static sptr make_adf4350(write_fn_t write); diff --git a/host/lib/include/uhdlib/usrp/common/fx2_ctrl.hpp b/host/lib/include/uhdlib/usrp/common/fx2_ctrl.hpp index 6aafa885b..8579787f4 100644 --- a/host/lib/include/uhdlib/usrp/common/fx2_ctrl.hpp +++ b/host/lib/include/uhdlib/usrp/common/fx2_ctrl.hpp @@ -11,7 +11,7 @@ #include <uhd/transport/usb_control.hpp> #include <uhd/types/serial.hpp> //i2c iface #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #define FL_BEGIN 0 #define FL_END 2 @@ -34,7 +34,7 @@ namespace uhd{ namespace usrp{ class fx2_ctrl : uhd::noncopyable, public uhd::i2c_iface{ public: - typedef boost::shared_ptr<fx2_ctrl> sptr; + typedef std::shared_ptr<fx2_ctrl> sptr; /*! * Make a usrp control object from a control transport diff --git a/host/lib/include/uhdlib/usrp/common/max287x.hpp b/host/lib/include/uhdlib/usrp/common/max287x.hpp index 92bc31630..51c22c5d8 100644 --- a/host/lib/include/uhdlib/usrp/common/max287x.hpp +++ b/host/lib/include/uhdlib/usrp/common/max287x.hpp @@ -30,7 +30,7 @@ class max287x_iface { public: - typedef boost::shared_ptr<max287x_iface> sptr; + typedef std::shared_ptr<max287x_iface> sptr; typedef boost::function<void(std::vector<uint32_t>)> write_fn; diff --git a/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer.hpp b/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer.hpp index d158a919e..c61e0ba99 100644 --- a/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer.hpp +++ b/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer.hpp @@ -10,14 +10,14 @@ #include <uhd/config.hpp> #include <uhd/transport/zero_copy.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <stdint.h> namespace uhd{ namespace usrp{ class recv_packet_demuxer{ public: - typedef boost::shared_ptr<recv_packet_demuxer> sptr; + typedef std::shared_ptr<recv_packet_demuxer> sptr; virtual ~recv_packet_demuxer(void) = 0; diff --git a/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer_3000.hpp b/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer_3000.hpp index 54ae10908..bb5b070c5 100644 --- a/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer_3000.hpp +++ b/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer_3000.hpp @@ -14,7 +14,7 @@ #include <uhd/types/time_spec.hpp> #include <uhd/utils/byteswap.hpp> #include <boost/thread.hpp> -#include <boost/enable_shared_from_this.hpp> +#include <memory> #include <queue> #include <map> #include <chrono> @@ -22,9 +22,9 @@ namespace uhd{ namespace usrp{ - struct recv_packet_demuxer_3000 : boost::enable_shared_from_this<recv_packet_demuxer_3000> + struct recv_packet_demuxer_3000 : std::enable_shared_from_this<recv_packet_demuxer_3000> { - typedef boost::shared_ptr<recv_packet_demuxer_3000> sptr; + typedef std::shared_ptr<recv_packet_demuxer_3000> sptr; static sptr make(transport::zero_copy_if::sptr xport) { return sptr(new recv_packet_demuxer_3000(xport)); diff --git a/host/lib/include/uhdlib/usrp/cores/gpio_atr_3000.hpp b/host/lib/include/uhdlib/usrp/cores/gpio_atr_3000.hpp index 2ab0cf4cf..ad7d4b588 100644 --- a/host/lib/include/uhdlib/usrp/cores/gpio_atr_3000.hpp +++ b/host/lib/include/uhdlib/usrp/cores/gpio_atr_3000.hpp @@ -14,14 +14,14 @@ #include <uhd/usrp/gpio_defs.hpp> #include <uhd/utils/noncopyable.hpp> #include <uhdlib/usrp/gpio_defs.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> namespace uhd { namespace usrp { namespace gpio_atr { class gpio_atr_3000 : uhd::noncopyable { public: - typedef boost::shared_ptr<gpio_atr_3000> sptr; + typedef std::shared_ptr<gpio_atr_3000> sptr; static const uint32_t MASK_SET_ALL = 0xFFFFFFFF; @@ -118,7 +118,7 @@ public: class db_gpio_atr_3000 { public: - typedef boost::shared_ptr<db_gpio_atr_3000> sptr; + typedef std::shared_ptr<db_gpio_atr_3000> sptr; typedef uhd::usrp::dboard_iface::unit_t db_unit_t; diff --git a/host/lib/include/uhdlib/usrp/cores/gpio_core_200.hpp b/host/lib/include/uhdlib/usrp/cores/gpio_core_200.hpp index 24c09c113..d6f104be1 100644 --- a/host/lib/include/uhdlib/usrp/cores/gpio_core_200.hpp +++ b/host/lib/include/uhdlib/usrp/cores/gpio_core_200.hpp @@ -12,14 +12,14 @@ #include <uhd/usrp/dboard_iface.hpp> #include <uhd/usrp/gpio_defs.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/types/wb_iface.hpp> #include <map> #include <stdint.h> class gpio_core_200 : uhd::noncopyable{ public: - typedef boost::shared_ptr<gpio_core_200> sptr; + typedef std::shared_ptr<gpio_core_200> sptr; typedef uhd::usrp::dboard_iface::unit_t unit_t; typedef uhd::usrp::dboard_iface::atr_reg_t atr_reg_t; @@ -58,7 +58,7 @@ public: //! Simple wrapper for 32 bit write only class gpio_core_200_32wo : uhd::noncopyable{ public: - typedef boost::shared_ptr<gpio_core_200_32wo> sptr; + typedef std::shared_ptr<gpio_core_200_32wo> sptr; typedef uhd::usrp::dboard_iface::atr_reg_t atr_reg_t; diff --git a/host/lib/include/uhdlib/usrp/cores/i2c_core_100_wb32.hpp b/host/lib/include/uhdlib/usrp/cores/i2c_core_100_wb32.hpp index 266f3e44a..42e57ca16 100644 --- a/host/lib/include/uhdlib/usrp/cores/i2c_core_100_wb32.hpp +++ b/host/lib/include/uhdlib/usrp/cores/i2c_core_100_wb32.hpp @@ -12,11 +12,11 @@ #include <uhd/types/serial.hpp> #include <uhd/utils/noncopyable.hpp> #include <uhd/types/wb_iface.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> class i2c_core_100_wb32 : uhd::noncopyable, public uhd::i2c_iface{ public: - typedef boost::shared_ptr<i2c_core_100_wb32> sptr; + typedef std::shared_ptr<i2c_core_100_wb32> sptr; virtual ~i2c_core_100_wb32(void) = 0; diff --git a/host/lib/include/uhdlib/usrp/cores/i2c_core_200.hpp b/host/lib/include/uhdlib/usrp/cores/i2c_core_200.hpp index f6c47f4bd..6d987b68a 100644 --- a/host/lib/include/uhdlib/usrp/cores/i2c_core_200.hpp +++ b/host/lib/include/uhdlib/usrp/cores/i2c_core_200.hpp @@ -12,12 +12,12 @@ #include <uhd/types/serial.hpp> #include <uhd/utils/noncopyable.hpp> #include <boost/utility.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/types/wb_iface.hpp> class i2c_core_200 : uhd::noncopyable, public uhd::i2c_iface{ public: - typedef boost::shared_ptr<i2c_core_200> sptr; + typedef std::shared_ptr<i2c_core_200> sptr; virtual ~i2c_core_200(void) = 0; diff --git a/host/lib/include/uhdlib/usrp/cores/radio_ctrl_core_3000.hpp b/host/lib/include/uhdlib/usrp/cores/radio_ctrl_core_3000.hpp index f7be7ef91..427a72586 100644 --- a/host/lib/include/uhdlib/usrp/cores/radio_ctrl_core_3000.hpp +++ b/host/lib/include/uhdlib/usrp/cores/radio_ctrl_core_3000.hpp @@ -12,7 +12,7 @@ #include <uhd/types/time_spec.hpp> #include <uhd/transport/zero_copy.hpp> #include <uhd/types/wb_iface.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/utility.hpp> #include <string> @@ -22,7 +22,7 @@ class radio_ctrl_core_3000 : public uhd::timed_wb_iface { public: - typedef boost::shared_ptr<radio_ctrl_core_3000> sptr; + typedef std::shared_ptr<radio_ctrl_core_3000> sptr; virtual ~radio_ctrl_core_3000(void) = 0; diff --git a/host/lib/include/uhdlib/usrp/cores/rx_dsp_core_200.hpp b/host/lib/include/uhdlib/usrp/cores/rx_dsp_core_200.hpp index ccf421c06..240838495 100644 --- a/host/lib/include/uhdlib/usrp/cores/rx_dsp_core_200.hpp +++ b/host/lib/include/uhdlib/usrp/cores/rx_dsp_core_200.hpp @@ -12,14 +12,14 @@ #include <uhd/stream.hpp> #include <uhd/types/ranges.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/types/stream_cmd.hpp> #include <uhd/types/wb_iface.hpp> #include <string> class rx_dsp_core_200 : uhd::noncopyable{ public: - typedef boost::shared_ptr<rx_dsp_core_200> sptr; + typedef std::shared_ptr<rx_dsp_core_200> sptr; virtual ~rx_dsp_core_200(void) = 0; diff --git a/host/lib/include/uhdlib/usrp/cores/rx_dsp_core_3000.hpp b/host/lib/include/uhdlib/usrp/cores/rx_dsp_core_3000.hpp index 8dbeab34f..f89d78191 100644 --- a/host/lib/include/uhdlib/usrp/cores/rx_dsp_core_3000.hpp +++ b/host/lib/include/uhdlib/usrp/cores/rx_dsp_core_3000.hpp @@ -16,7 +16,7 @@ #include <uhd/types/wb_iface.hpp> #include <uhd/usrp/fe_connection.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <string> class rx_dsp_core_3000 : uhd::noncopyable @@ -26,7 +26,7 @@ public: static const double DEFAULT_DDS_FREQ; static const double DEFAULT_RATE; - typedef boost::shared_ptr<rx_dsp_core_3000> sptr; + typedef std::shared_ptr<rx_dsp_core_3000> sptr; virtual ~rx_dsp_core_3000(void) = 0; diff --git a/host/lib/include/uhdlib/usrp/cores/rx_frontend_core_200.hpp b/host/lib/include/uhdlib/usrp/cores/rx_frontend_core_200.hpp index bfba94b10..6a91f83da 100644 --- a/host/lib/include/uhdlib/usrp/cores/rx_frontend_core_200.hpp +++ b/host/lib/include/uhdlib/usrp/cores/rx_frontend_core_200.hpp @@ -12,7 +12,7 @@ #include <uhd/types/wb_iface.hpp> #include <uhd/property_tree.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <complex> #include <string> @@ -22,7 +22,7 @@ public: static const bool DEFAULT_DC_OFFSET_ENABLE; static const std::complex<double> DEFAULT_IQ_BALANCE_VALUE; - typedef boost::shared_ptr<rx_frontend_core_200> sptr; + typedef std::shared_ptr<rx_frontend_core_200> sptr; virtual ~rx_frontend_core_200(void) = 0; diff --git a/host/lib/include/uhdlib/usrp/cores/rx_frontend_core_3000.hpp b/host/lib/include/uhdlib/usrp/cores/rx_frontend_core_3000.hpp index 2d20c63fa..b1dfd307e 100644 --- a/host/lib/include/uhdlib/usrp/cores/rx_frontend_core_3000.hpp +++ b/host/lib/include/uhdlib/usrp/cores/rx_frontend_core_3000.hpp @@ -13,7 +13,7 @@ #include <uhd/types/wb_iface.hpp> #include <uhd/usrp/fe_connection.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <complex> #include <string> @@ -24,7 +24,7 @@ public: static const bool DEFAULT_DC_OFFSET_ENABLE; static const std::complex<double> DEFAULT_IQ_BALANCE_VALUE; - typedef boost::shared_ptr<rx_frontend_core_3000> sptr; + typedef std::shared_ptr<rx_frontend_core_3000> sptr; virtual ~rx_frontend_core_3000(void) = 0; diff --git a/host/lib/include/uhdlib/usrp/cores/rx_vita_core_3000.hpp b/host/lib/include/uhdlib/usrp/cores/rx_vita_core_3000.hpp index 7205e3b5f..615ca2319 100644 --- a/host/lib/include/uhdlib/usrp/cores/rx_vita_core_3000.hpp +++ b/host/lib/include/uhdlib/usrp/cores/rx_vita_core_3000.hpp @@ -12,7 +12,7 @@ #include <uhd/stream.hpp> #include <uhd/types/ranges.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/types/stream_cmd.hpp> #include <uhd/types/wb_iface.hpp> #include <string> @@ -20,7 +20,7 @@ class rx_vita_core_3000 : uhd::noncopyable { public: - typedef boost::shared_ptr<rx_vita_core_3000> sptr; + typedef std::shared_ptr<rx_vita_core_3000> sptr; virtual ~rx_vita_core_3000(void) = 0; diff --git a/host/lib/include/uhdlib/usrp/cores/spi_core_3000.hpp b/host/lib/include/uhdlib/usrp/cores/spi_core_3000.hpp index 36486b5a1..4d08071f7 100644 --- a/host/lib/include/uhdlib/usrp/cores/spi_core_3000.hpp +++ b/host/lib/include/uhdlib/usrp/cores/spi_core_3000.hpp @@ -12,14 +12,14 @@ #include <uhd/types/serial.hpp> #include <uhd/utils/noncopyable.hpp> #include <uhd/types/wb_iface.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <memory> #include <functional> class spi_core_3000 : uhd::noncopyable, public uhd::spi_iface { public: - using sptr = boost::shared_ptr<spi_core_3000>; + using sptr = std::shared_ptr<spi_core_3000>; using poke32_fn_t = std::function<void(uint32_t, uint32_t)>; using peek32_fn_t = std::function<uint32_t(uint32_t)>; diff --git a/host/lib/include/uhdlib/usrp/cores/time64_core_200.hpp b/host/lib/include/uhdlib/usrp/cores/time64_core_200.hpp index 883a83edb..4001d7d4d 100644 --- a/host/lib/include/uhdlib/usrp/cores/time64_core_200.hpp +++ b/host/lib/include/uhdlib/usrp/cores/time64_core_200.hpp @@ -13,13 +13,13 @@ #include <uhd/utils/noncopyable.hpp> #include <uhd/types/wb_iface.hpp> #include <boost/utility.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <string> #include <vector> class time64_core_200 : uhd::noncopyable{ public: - typedef boost::shared_ptr<time64_core_200> sptr; + typedef std::shared_ptr<time64_core_200> sptr; struct readback_bases_type{ size_t rb_hi_now, rb_lo_now; diff --git a/host/lib/include/uhdlib/usrp/cores/time_core_3000.hpp b/host/lib/include/uhdlib/usrp/cores/time_core_3000.hpp index 1f3fa8129..8031ed130 100644 --- a/host/lib/include/uhdlib/usrp/cores/time_core_3000.hpp +++ b/host/lib/include/uhdlib/usrp/cores/time_core_3000.hpp @@ -11,13 +11,13 @@ #include <uhd/config.hpp> #include <uhd/types/time_spec.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/types/wb_iface.hpp> class time_core_3000 : uhd::noncopyable { public: - typedef boost::shared_ptr<time_core_3000> sptr; + typedef std::shared_ptr<time_core_3000> sptr; struct readback_bases_type { diff --git a/host/lib/include/uhdlib/usrp/cores/tx_dsp_core_200.hpp b/host/lib/include/uhdlib/usrp/cores/tx_dsp_core_200.hpp index 6ddbf9fbd..86a704c66 100644 --- a/host/lib/include/uhdlib/usrp/cores/tx_dsp_core_200.hpp +++ b/host/lib/include/uhdlib/usrp/cores/tx_dsp_core_200.hpp @@ -12,12 +12,12 @@ #include <uhd/stream.hpp> #include <uhd/types/ranges.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/types/wb_iface.hpp> class tx_dsp_core_200 : uhd::noncopyable{ public: - typedef boost::shared_ptr<tx_dsp_core_200> sptr; + typedef std::shared_ptr<tx_dsp_core_200> sptr; virtual ~tx_dsp_core_200(void) = 0; diff --git a/host/lib/include/uhdlib/usrp/cores/tx_dsp_core_3000.hpp b/host/lib/include/uhdlib/usrp/cores/tx_dsp_core_3000.hpp index c7cf07b6a..5dbded392 100644 --- a/host/lib/include/uhdlib/usrp/cores/tx_dsp_core_3000.hpp +++ b/host/lib/include/uhdlib/usrp/cores/tx_dsp_core_3000.hpp @@ -14,7 +14,7 @@ #include <uhd/types/ranges.hpp> #include <uhd/types/wb_iface.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> class tx_dsp_core_3000 : uhd::noncopyable { @@ -23,7 +23,7 @@ public: static const double DEFAULT_DDS_FREQ; static const double DEFAULT_RATE; - typedef boost::shared_ptr<tx_dsp_core_3000> sptr; + typedef std::shared_ptr<tx_dsp_core_3000> sptr; virtual ~tx_dsp_core_3000(void) = 0; diff --git a/host/lib/include/uhdlib/usrp/cores/tx_frontend_core_200.hpp b/host/lib/include/uhdlib/usrp/cores/tx_frontend_core_200.hpp index ae071c715..8a7178bb4 100644 --- a/host/lib/include/uhdlib/usrp/cores/tx_frontend_core_200.hpp +++ b/host/lib/include/uhdlib/usrp/cores/tx_frontend_core_200.hpp @@ -12,13 +12,13 @@ #include <uhd/types/wb_iface.hpp> #include <uhd/property_tree.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <complex> #include <string> class tx_frontend_core_200 : uhd::noncopyable{ public: - typedef boost::shared_ptr<tx_frontend_core_200> sptr; + typedef std::shared_ptr<tx_frontend_core_200> sptr; static const std::complex<double> DEFAULT_DC_OFFSET_VALUE; static const std::complex<double> DEFAULT_IQ_BALANCE_VALUE; diff --git a/host/lib/include/uhdlib/usrp/cores/tx_vita_core_3000.hpp b/host/lib/include/uhdlib/usrp/cores/tx_vita_core_3000.hpp index 57d27d6b3..9d03549de 100644 --- a/host/lib/include/uhdlib/usrp/cores/tx_vita_core_3000.hpp +++ b/host/lib/include/uhdlib/usrp/cores/tx_vita_core_3000.hpp @@ -12,7 +12,7 @@ #include <uhd/stream.hpp> #include <uhd/types/ranges.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/types/stream_cmd.hpp> #include <uhd/types/wb_iface.hpp> #include <string> @@ -20,7 +20,7 @@ class tx_vita_core_3000 : uhd::noncopyable { public: - typedef boost::shared_ptr<tx_vita_core_3000> sptr; + typedef std::shared_ptr<tx_vita_core_3000> sptr; enum fc_monitor_loc { FC_DEFAULT, diff --git a/host/lib/include/uhdlib/usrp/cores/user_settings_core_200.hpp b/host/lib/include/uhdlib/usrp/cores/user_settings_core_200.hpp index e466e6e44..810c8fd7e 100644 --- a/host/lib/include/uhdlib/usrp/cores/user_settings_core_200.hpp +++ b/host/lib/include/uhdlib/usrp/cores/user_settings_core_200.hpp @@ -12,11 +12,11 @@ #include <uhd/utils/noncopyable.hpp> #include <uhd/types/wb_iface.hpp> #include <boost/utility.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> class user_settings_core_200 : uhd::noncopyable{ public: - typedef boost::shared_ptr<user_settings_core_200> sptr; + typedef std::shared_ptr<user_settings_core_200> sptr; typedef std::pair<uint8_t, uint32_t> user_reg_t; virtual ~user_settings_core_200(void) = 0; diff --git a/host/lib/include/uhdlib/usrp/cores/user_settings_core_3000.hpp b/host/lib/include/uhdlib/usrp/cores/user_settings_core_3000.hpp index bc281e396..4b6d0bd6c 100644 --- a/host/lib/include/uhdlib/usrp/cores/user_settings_core_3000.hpp +++ b/host/lib/include/uhdlib/usrp/cores/user_settings_core_3000.hpp @@ -10,7 +10,7 @@ #include <uhd/config.hpp> #include <boost/utility.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/types/wb_iface.hpp> class user_settings_core_3000 : public uhd::wb_iface { diff --git a/host/lib/property_tree.cpp b/host/lib/property_tree.cpp index 6f797bc2e..599f610ad 100644 --- a/host/lib/property_tree.cpp +++ b/host/lib/property_tree.cpp @@ -8,7 +8,7 @@ #include <uhd/property_tree.hpp> #include <uhd/types/dict.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <boost/thread/mutex.hpp> #include <iostream> #include <typeindex> @@ -74,7 +74,7 @@ class property_tree_impl : public uhd::property_tree public: property_tree_impl(const fs_path& root = fs_path()) : _root(root) { - _guts = boost::make_shared<tree_guts_type>(); + _guts = std::make_shared<tree_guts_type>(); } sptr subtree(const fs_path& path_) const @@ -134,7 +134,7 @@ public: return node->keys(); } - boost::shared_ptr<void> _pop(const fs_path& path_) + std::shared_ptr<void> _pop(const fs_path& path_) { const fs_path path = _root / path_; boost::mutex::scoped_lock lock(_guts->mutex); @@ -157,7 +157,7 @@ public: return prop; } - void _create(const fs_path& path_, const boost::shared_ptr<void>& prop, + void _create(const fs_path& path_, const std::shared_ptr<void>& prop, std::type_index prop_type) { const fs_path path = _root / path_; @@ -176,7 +176,7 @@ public: node->prop_type_hash = prop_type.hash_code(); } - boost::shared_ptr<void>& _access(const fs_path& path_) const + std::shared_ptr<void>& _access(const fs_path& path_) const { const fs_path path = _root / path_; boost::mutex::scoped_lock lock(_guts->mutex); @@ -192,7 +192,7 @@ public: return node->prop; } - boost::shared_ptr<void>& _access_with_type_check( + std::shared_ptr<void>& _access_with_type_check( const fs_path& path_, std::type_index expected_prop_type) const { const fs_path path = _root / path_; @@ -220,7 +220,7 @@ private: // basic structural node element struct node_type : uhd::dict<std::string, node_type> { - boost::shared_ptr<void> prop; + std::shared_ptr<void> prop; std::size_t prop_type_hash; }; @@ -232,7 +232,7 @@ private: }; // members, the tree and root prefix - boost::shared_ptr<tree_guts_type> _guts; + std::shared_ptr<tree_guts_type> _guts; const fs_path _root; }; diff --git a/host/lib/rfnoc/graph_stream_manager.cpp b/host/lib/rfnoc/graph_stream_manager.cpp index dcfa88f32..dba913998 100644 --- a/host/lib/rfnoc/graph_stream_manager.cpp +++ b/host/lib/rfnoc/graph_stream_manager.cpp @@ -10,7 +10,7 @@ #include <uhdlib/rfnoc/link_stream_manager.hpp> #include <uhdlib/transport/links.hpp> #include <boost/format.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <map> #include <set> diff --git a/host/lib/rfnoc/rfnoc_graph.cpp b/host/lib/rfnoc/rfnoc_graph.cpp index a6ec59d01..929ce518d 100644 --- a/host/lib/rfnoc/rfnoc_graph.cpp +++ b/host/lib/rfnoc/rfnoc_graph.cpp @@ -19,8 +19,6 @@ #include <uhdlib/rfnoc/rfnoc_rx_streamer.hpp> #include <uhdlib/rfnoc/rfnoc_tx_streamer.hpp> #include <uhdlib/utils/narrow.hpp> -#include <boost/make_shared.hpp> -#include <boost/shared_ptr.hpp> // FIXME remove when rfnoc_device is ready #include <memory> using namespace uhd; @@ -215,7 +213,7 @@ public: uhd::transport::adapter_id_t adapter_id) { // Verify the streamer was created by us - auto rfnoc_streamer = boost::dynamic_pointer_cast<rfnoc_tx_streamer>(streamer); + auto rfnoc_streamer = std::dynamic_pointer_cast<rfnoc_tx_streamer>(streamer); if (!rfnoc_streamer) { throw uhd::type_error("Streamer is not rfnoc capable"); } @@ -271,7 +269,7 @@ public: uhd::transport::adapter_id_t adapter_id) { // Verify the streamer was created by us - auto rfnoc_streamer = boost::dynamic_pointer_cast<rfnoc_rx_streamer>(streamer); + auto rfnoc_streamer = std::dynamic_pointer_cast<rfnoc_rx_streamer>(streamer); if (!rfnoc_streamer) { throw uhd::type_error("Streamer is not rfnoc capable"); } @@ -323,14 +321,14 @@ public: uhd::rx_streamer::sptr create_rx_streamer( const size_t num_chans, const uhd::stream_args_t& args) { - _rx_streamers.push_back(boost::make_shared<rfnoc_rx_streamer>(num_chans, args)); + _rx_streamers.push_back(std::make_shared<rfnoc_rx_streamer>(num_chans, args)); return _rx_streamers.back(); } uhd::tx_streamer::sptr create_tx_streamer( const size_t num_chans, const uhd::stream_args_t& args) { - _tx_streamers.push_back(boost::make_shared<rfnoc_tx_streamer>(num_chans, args)); + _tx_streamers.push_back(std::make_shared<rfnoc_tx_streamer>(num_chans, args)); return _tx_streamers.back(); } @@ -905,7 +903,7 @@ rfnoc_graph::sptr make_rfnoc_graph( rfnoc_graph::sptr rfnoc_graph::make(const uhd::device_addr_t& device_addr) { auto dev = - boost::dynamic_pointer_cast<detail::rfnoc_device>(uhd::device::make(device_addr)); + std::dynamic_pointer_cast<detail::rfnoc_device>(uhd::device::make(device_addr)); if (!dev) { throw uhd::key_error(std::string("No RFNoC devices found for ----->\n") + device_addr.to_pp_string()); diff --git a/host/lib/transport/dpdk_zero_copy.cpp b/host/lib/transport/dpdk_zero_copy.cpp index a6a158762..99df3b059 100644 --- a/host/lib/transport/dpdk_zero_copy.cpp +++ b/host/lib/transport/dpdk_zero_copy.cpp @@ -11,7 +11,7 @@ #include <uhdlib/utils/prefs.hpp> #include <boost/algorithm/string.hpp> #include <boost/format.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <stack> #include <sys/syslog.h> #include <arpa/inet.h> diff --git a/host/lib/transport/libusb1_base.cpp b/host/lib/transport/libusb1_base.cpp index d383b0a3e..03ab51770 100644 --- a/host/lib/transport/libusb1_base.cpp +++ b/host/lib/transport/libusb1_base.cpp @@ -13,10 +13,10 @@ #include <uhd/utils/tasks.hpp> #include <boost/bind.hpp> #include <boost/thread/mutex.hpp> -#include <boost/weak_ptr.hpp> #include <cstdlib> #include <iostream> #include <mutex> +#include <memory> using namespace uhd; using namespace uhd::transport; @@ -86,7 +86,7 @@ libusb_session_impl::~libusb_session_impl(void) libusb::session::sptr libusb::session::get_global_session(void) { - static boost::weak_ptr<session> global_session; + static std::weak_ptr<session> global_session; // this mutex is to ensure a global session is not currently being created // before checking for the existence of one static std::mutex global_session_mutex; @@ -336,7 +336,7 @@ libusb_device_handle_impl::~libusb_device_handle_impl(void) libusb::device_handle::sptr libusb::device_handle::get_cached_handle(device::sptr dev) { - static uhd::dict<libusb_device*, boost::weak_ptr<device_handle>> handles; + static uhd::dict<libusb_device*, std::weak_ptr<device_handle>> handles; // lock for atomic access to static table above static boost::mutex mutex; diff --git a/host/lib/transport/libusb1_base.hpp b/host/lib/transport/libusb1_base.hpp index deb535ecb..5d909a664 100644 --- a/host/lib/transport/libusb1_base.hpp +++ b/host/lib/transport/libusb1_base.hpp @@ -11,7 +11,7 @@ #include <uhd/config.hpp> #include <uhd/transport/usb_device_handle.hpp> #include <libusb.h> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/utils/noncopyable.hpp> //! Define LIBUSB_CALL when its missing (non-windows) @@ -52,7 +52,7 @@ namespace uhd { namespace transport { namespace libusb { class session : uhd::noncopyable { public: - typedef boost::shared_ptr<session> sptr; + typedef std::shared_ptr<session> sptr; virtual ~session(void); @@ -78,7 +78,7 @@ public: class device : uhd::noncopyable { public: - typedef boost::shared_ptr<device> sptr; + typedef std::shared_ptr<device> sptr; virtual ~device(void); @@ -93,7 +93,7 @@ public: class device_list : uhd::noncopyable { public: - typedef boost::shared_ptr<device_list> sptr; + typedef std::shared_ptr<device_list> sptr; virtual ~device_list(void); @@ -113,7 +113,7 @@ public: class device_descriptor : uhd::noncopyable { public: - typedef boost::shared_ptr<device_descriptor> sptr; + typedef std::shared_ptr<device_descriptor> sptr; virtual ~device_descriptor(void); @@ -132,7 +132,7 @@ public: class device_handle : uhd::noncopyable { public: - typedef boost::shared_ptr<device_handle> sptr; + typedef std::shared_ptr<device_handle> sptr; virtual ~device_handle(void); @@ -163,7 +163,7 @@ public: class special_handle : public usb_device_handle { public: - typedef boost::shared_ptr<special_handle> sptr; + typedef std::shared_ptr<special_handle> sptr; virtual ~special_handle(void); diff --git a/host/lib/transport/libusb1_control.cpp b/host/lib/transport/libusb1_control.cpp index 10ab53553..b7aefe1c6 100644 --- a/host/lib/transport/libusb1_control.cpp +++ b/host/lib/transport/libusb1_control.cpp @@ -66,6 +66,6 @@ usb_control::sptr usb_control::make(usb_device_handle::sptr handle, const int in { return sptr(new libusb_control_impl( libusb::device_handle::get_cached_handle( - boost::static_pointer_cast<libusb::special_handle>(handle)->get_device()), + std::static_pointer_cast<libusb::special_handle>(handle)->get_device()), interface)); } diff --git a/host/lib/transport/libusb1_zero_copy.cpp b/host/lib/transport/libusb1_zero_copy.cpp index 9a1b74fb2..fbeddbcdd 100644 --- a/host/lib/transport/libusb1_zero_copy.cpp +++ b/host/lib/transport/libusb1_zero_copy.cpp @@ -16,7 +16,7 @@ #include <boost/circular_buffer.hpp> #include <boost/format.hpp> #include <boost/function.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <boost/thread/condition_variable.hpp> #include <boost/thread/mutex.hpp> #include <list> @@ -29,7 +29,7 @@ static const size_t DEFAULT_XFER_SIZE = 32 * 512; // bytes //! type for sharing the release queue with managed buffers class libusb_zero_copy_mb; -typedef boost::shared_ptr<bounded_buffer<libusb_zero_copy_mb*>> mb_queue_sptr; +typedef std::shared_ptr<bounded_buffer<libusb_zero_copy_mb*>> mb_queue_sptr; /*! * The libusb docs state that status and actual length can only be read in the callback. @@ -251,7 +251,7 @@ public: libusb_transfer* lut = libusb_alloc_transfer(0); UHD_ASSERT_THROW(lut != NULL); - _mb_pool.push_back(boost::make_shared<libusb_zero_copy_mb>(lut, + _mb_pool.push_back(std::make_shared<libusb_zero_copy_mb>(lut, this->get_frame_size(), boost::bind(&libusb_zero_copy_single::enqueue_buffer, this, _1), is_recv, @@ -345,7 +345,7 @@ private: //! Storage for transfer related objects buffer_pool::sptr _buffer_pool; - std::vector<boost::shared_ptr<libusb_zero_copy_mb>> _mb_pool; + std::vector<std::shared_ptr<libusb_zero_copy_mb>> _mb_pool; boost::mutex _queue_mutex; boost::condition_variable _buff_ready_cond; @@ -440,7 +440,7 @@ struct libusb_zero_copy_impl : usb_zero_copy return _send_impl->get_frame_size(); } - boost::shared_ptr<libusb_zero_copy_single> _recv_impl, _send_impl; + std::shared_ptr<libusb_zero_copy_single> _recv_impl, _send_impl; boost::mutex _recv_mutex, _send_mutex; }; @@ -468,7 +468,7 @@ usb_zero_copy::sptr usb_zero_copy::make(usb_device_handle::sptr handle, const device_addr_t& hints) { libusb::device_handle::sptr dev_handle(libusb::device_handle::get_cached_handle( - boost::static_pointer_cast<libusb::special_handle>(handle)->get_device())); + std::static_pointer_cast<libusb::special_handle>(handle)->get_device())); return sptr(new libusb_zero_copy_impl( dev_handle, recv_interface, recv_endpoint, send_interface, send_endpoint, hints)); } diff --git a/host/lib/transport/muxed_zero_copy_if.cpp b/host/lib/transport/muxed_zero_copy_if.cpp index a3ea4c40d..532c3d3b2 100644 --- a/host/lib/transport/muxed_zero_copy_if.cpp +++ b/host/lib/transport/muxed_zero_copy_if.cpp @@ -9,21 +9,20 @@ #include <uhd/transport/bounded_buffer.hpp> #include <uhd/transport/muxed_zero_copy_if.hpp> #include <uhd/utils/safe_call.hpp> -#include <boost/enable_shared_from_this.hpp> -#include <boost/make_shared.hpp> #include <boost/thread.hpp> #include <boost/thread/locks.hpp> #include <map> +#include <memory> using namespace uhd; using namespace uhd::transport; class muxed_zero_copy_if_impl : public muxed_zero_copy_if, - public boost::enable_shared_from_this<muxed_zero_copy_if_impl> + public std::enable_shared_from_this<muxed_zero_copy_if_impl> { public: - typedef boost::shared_ptr<muxed_zero_copy_if_impl> sptr; + typedef std::shared_ptr<muxed_zero_copy_if_impl> sptr; muxed_zero_copy_if_impl(zero_copy_if::sptr base_xport, stream_classifier_fn classify_fn, @@ -68,7 +67,7 @@ public: // Only allocate a portion of the base transport's frames to each stream // to prevent all streams from attempting to use all the frames. stream_impl::sptr stream = - boost::make_shared<stream_impl>(this->shared_from_this(), + std::make_shared<stream_impl>(this->shared_from_this(), stream_num, _base_xport->get_num_send_frames(), _base_xport->get_num_recv_frames()); @@ -117,8 +116,8 @@ private: class stream_impl : public zero_copy_if { public: - typedef boost::shared_ptr<stream_impl> sptr; - typedef boost::weak_ptr<stream_impl> wptr; + typedef std::shared_ptr<stream_impl> sptr; + typedef std::weak_ptr<stream_impl> wptr; stream_impl(muxed_zero_copy_if_impl::sptr muxed_xport, const uint32_t stream_num, @@ -135,7 +134,7 @@ private: , _buffer_index(0) { for (size_t i = 0; i < num_recv_frames; i++) { - _buffers[i] = boost::make_shared<stream_mrb>(_recv_frame_size); + _buffers[i] = std::make_shared<stream_mrb>(_recv_frame_size); } } @@ -201,7 +200,7 @@ private: const size_t _num_recv_frames; const size_t _recv_frame_size; bounded_buffer<managed_recv_buffer::sptr> _buff_queue; - std::vector<boost::shared_ptr<stream_mrb>> _buffers; + std::vector<std::shared_ptr<stream_mrb>> _buffers; size_t _buffer_index; }; @@ -299,6 +298,6 @@ muxed_zero_copy_if::sptr muxed_zero_copy_if::make(zero_copy_if::sptr base_xport, muxed_zero_copy_if::stream_classifier_fn classify_fn, size_t max_streams) { - return boost::make_shared<muxed_zero_copy_if_impl>( + return std::make_shared<muxed_zero_copy_if_impl>( base_xport, classify_fn, max_streams); } diff --git a/host/lib/transport/nirio_zero_copy.cpp b/host/lib/transport/nirio_zero_copy.cpp index 9cd6644f1..f54e5a8ed 100644 --- a/host/lib/transport/nirio_zero_copy.cpp +++ b/host/lib/transport/nirio_zero_copy.cpp @@ -13,7 +13,7 @@ #include <boost/date_time/posix_time/posix_time.hpp> #include <boost/format.hpp> #include <boost/interprocess/mapped_region.hpp> //get_page_size() -#include <boost/make_shared.hpp> +#include <memory> #include <algorithm> // std::max #include <chrono> #include <thread> @@ -136,7 +136,7 @@ private: class nirio_zero_copy_impl : public nirio_zero_copy { public: - typedef boost::shared_ptr<nirio_zero_copy_impl> sptr; + typedef std::shared_ptr<nirio_zero_copy_impl> sptr; nirio_zero_copy_impl(uhd::niusrprio::niusrprio_session::sptr fpga_session, uint32_t instance, @@ -224,13 +224,13 @@ public: if (nirio_status_not_fatal(status)) { // allocate re-usable managed receive buffers for (size_t i = 0; i < get_num_recv_frames(); i++) { - _mrb_pool.push_back(boost::shared_ptr<nirio_zero_copy_mrb>( + _mrb_pool.push_back(std::shared_ptr<nirio_zero_copy_mrb>( new nirio_zero_copy_mrb(*_recv_fifo, get_recv_frame_size()))); } // allocate re-usable managed send buffers for (size_t i = 0; i < get_num_send_frames(); i++) { - _msb_pool.push_back(boost::shared_ptr<nirio_zero_copy_msb>( + _msb_pool.push_back(std::shared_ptr<nirio_zero_copy_msb>( new nirio_zero_copy_msb(*_send_fifo, get_send_frame_size()))); } } @@ -383,8 +383,8 @@ private: uint32_t _fifo_instance; nirio_fifo<fifo_data_t>::sptr _recv_fifo, _send_fifo; const zero_copy_xport_params _xport_params; - std::vector<boost::shared_ptr<nirio_zero_copy_msb>> _msb_pool; - std::vector<boost::shared_ptr<nirio_zero_copy_mrb>> _mrb_pool; + std::vector<std::shared_ptr<nirio_zero_copy_msb>> _msb_pool; + std::vector<std::shared_ptr<nirio_zero_copy_mrb>> _mrb_pool; size_t _next_recv_buff_index, _next_send_buff_index; }; diff --git a/host/lib/transport/super_recv_packet_handler.hpp b/host/lib/transport/super_recv_packet_handler.hpp index 950da4c8a..a09281459 100644 --- a/host/lib/transport/super_recv_packet_handler.hpp +++ b/host/lib/transport/super_recv_packet_handler.hpp @@ -21,7 +21,7 @@ #include <boost/dynamic_bitset.hpp> #include <boost/format.hpp> #include <boost/function.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <iostream> #include <vector> diff --git a/host/lib/transport/tcp_zero_copy.cpp b/host/lib/transport/tcp_zero_copy.cpp index 01bca900f..555dd238e 100644 --- a/host/lib/transport/tcp_zero_copy.cpp +++ b/host/lib/transport/tcp_zero_copy.cpp @@ -11,7 +11,7 @@ #include <uhdlib/utils/atomic.hpp> #include <uhdlib/transport/udp_common.hpp> #include <boost/format.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <chrono> #include <thread> #include <vector> @@ -133,7 +133,7 @@ tcp_zero_copy::~tcp_zero_copy(void) class tcp_zero_copy_asio_impl : public tcp_zero_copy { public: - typedef boost::shared_ptr<tcp_zero_copy_asio_impl> sptr; + typedef std::shared_ptr<tcp_zero_copy_asio_impl> sptr; tcp_zero_copy_asio_impl( const std::string& addr, const std::string& port, const device_addr_t& hints) @@ -169,13 +169,13 @@ public: // allocate re-usable managed receive buffers for (size_t i = 0; i < get_num_recv_frames(); i++) { - _mrb_pool.push_back(boost::make_shared<tcp_zero_copy_asio_mrb>( + _mrb_pool.push_back(std::make_shared<tcp_zero_copy_asio_mrb>( _recv_buffer_pool->at(i), _sock_fd, get_recv_frame_size())); } // allocate re-usable managed send buffers for (size_t i = 0; i < get_num_send_frames(); i++) { - _msb_pool.push_back(boost::make_shared<tcp_zero_copy_asio_msb>( + _msb_pool.push_back(std::make_shared<tcp_zero_copy_asio_msb>( _send_buffer_pool->at(i), _sock_fd, get_send_frame_size())); } } @@ -225,13 +225,13 @@ private: const size_t _recv_frame_size, _num_recv_frames; const size_t _send_frame_size, _num_send_frames; buffer_pool::sptr _recv_buffer_pool, _send_buffer_pool; - std::vector<boost::shared_ptr<tcp_zero_copy_asio_msb>> _msb_pool; - std::vector<boost::shared_ptr<tcp_zero_copy_asio_mrb>> _mrb_pool; + std::vector<std::shared_ptr<tcp_zero_copy_asio_msb>> _msb_pool; + std::vector<std::shared_ptr<tcp_zero_copy_asio_mrb>> _mrb_pool; size_t _next_recv_buff_index, _next_send_buff_index; // asio guts -> socket and service asio::io_service _io_service; - boost::shared_ptr<asio::ip::tcp::socket> _socket; + std::shared_ptr<asio::ip::tcp::socket> _socket; int _sock_fd; }; diff --git a/host/lib/transport/udp_wsa_zero_copy.cpp b/host/lib/transport/udp_wsa_zero_copy.cpp index 36837cda4..b4880478a 100644 --- a/host/lib/transport/udp_wsa_zero_copy.cpp +++ b/host/lib/transport/udp_wsa_zero_copy.cpp @@ -187,7 +187,7 @@ private: class udp_zero_copy_wsa_impl : public udp_zero_copy { public: - typedef boost::shared_ptr<udp_zero_copy_wsa_impl> sptr; + typedef std::shared_ptr<udp_zero_copy_wsa_impl> sptr; udp_zero_copy_wsa_impl(const std::string& addr, const std::string& port, @@ -272,14 +272,14 @@ public: // allocate re-usable managed receive buffers for (size_t i = 0; i < get_num_recv_frames(); i++) { _mrb_pool.push_back( - boost::shared_ptr<udp_zero_copy_asio_mrb>(new udp_zero_copy_asio_mrb( + std::shared_ptr<udp_zero_copy_asio_mrb>(new udp_zero_copy_asio_mrb( _recv_buffer_pool->at(i), _sock_fd, get_recv_frame_size()))); } // allocate re-usable managed send buffers for (size_t i = 0; i < get_num_send_frames(); i++) { _msb_pool.push_back( - boost::shared_ptr<udp_zero_copy_asio_msb>(new udp_zero_copy_asio_msb( + std::shared_ptr<udp_zero_copy_asio_msb>(new udp_zero_copy_asio_msb( _send_buffer_pool->at(i), _sock_fd, get_send_frame_size()))); } } @@ -383,8 +383,8 @@ private: const size_t _recv_frame_size, _num_recv_frames; const size_t _send_frame_size, _num_send_frames; buffer_pool::sptr _recv_buffer_pool, _send_buffer_pool; - std::vector<boost::shared_ptr<udp_zero_copy_asio_msb>> _msb_pool; - std::vector<boost::shared_ptr<udp_zero_copy_asio_mrb>> _mrb_pool; + std::vector<std::shared_ptr<udp_zero_copy_asio_msb>> _msb_pool; + std::vector<std::shared_ptr<udp_zero_copy_asio_mrb>> _mrb_pool; size_t _next_recv_buff_index, _next_send_buff_index; // socket guts diff --git a/host/lib/transport/udp_zero_copy.cpp b/host/lib/transport/udp_zero_copy.cpp index 44df9526d..883b2a68a 100644 --- a/host/lib/transport/udp_zero_copy.cpp +++ b/host/lib/transport/udp_zero_copy.cpp @@ -11,7 +11,7 @@ #include <uhdlib/transport/udp_common.hpp> #include <uhdlib/utils/atomic.hpp> #include <boost/format.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <chrono> #include <thread> #include <vector> @@ -138,7 +138,7 @@ private: class udp_zero_copy_asio_impl : public udp_zero_copy { public: - typedef boost::shared_ptr<udp_zero_copy_asio_impl> sptr; + typedef std::shared_ptr<udp_zero_copy_asio_impl> sptr; udp_zero_copy_asio_impl(const std::string& addr, const std::string& port, @@ -169,13 +169,13 @@ public: // allocate re-usable managed receive buffers for (size_t i = 0; i < get_num_recv_frames(); i++) { - _mrb_pool.push_back(boost::make_shared<udp_zero_copy_asio_mrb>( + _mrb_pool.push_back(std::make_shared<udp_zero_copy_asio_mrb>( _recv_buffer_pool->at(i), _sock_fd, get_recv_frame_size())); } // allocate re-usable managed send buffers for (size_t i = 0; i < get_num_send_frames(); i++) { - _msb_pool.push_back(boost::make_shared<udp_zero_copy_asio_msb>( + _msb_pool.push_back(std::make_shared<udp_zero_copy_asio_msb>( _send_buffer_pool->at(i), _sock_fd, get_send_frame_size())); } } @@ -247,8 +247,8 @@ private: const size_t _recv_frame_size, _num_recv_frames; const size_t _send_frame_size, _num_send_frames; buffer_pool::sptr _recv_buffer_pool, _send_buffer_pool; - std::vector<boost::shared_ptr<udp_zero_copy_asio_msb>> _msb_pool; - std::vector<boost::shared_ptr<udp_zero_copy_asio_mrb>> _mrb_pool; + std::vector<std::shared_ptr<udp_zero_copy_asio_msb>> _msb_pool; + std::vector<std::shared_ptr<udp_zero_copy_asio_mrb>> _mrb_pool; size_t _next_recv_buff_index, _next_send_buff_index; // asio guts -> socket and service diff --git a/host/lib/transport/zero_copy_flow_ctrl.cpp b/host/lib/transport/zero_copy_flow_ctrl.cpp index 7d1ddd7e0..f92b826db 100644 --- a/host/lib/transport/zero_copy_flow_ctrl.cpp +++ b/host/lib/transport/zero_copy_flow_ctrl.cpp @@ -12,7 +12,7 @@ #include <uhd/utils/safe_call.hpp> #include <boost/bind.hpp> #include <boost/format.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <boost/thread/mutex.hpp> #include <boost/thread/thread.hpp> @@ -97,7 +97,7 @@ private: class zero_copy_flow_ctrl_impl : public zero_copy_flow_ctrl { public: - typedef boost::shared_ptr<zero_copy_flow_ctrl_impl> sptr; + typedef std::shared_ptr<zero_copy_flow_ctrl_impl> sptr; zero_copy_flow_ctrl_impl(zero_copy_if::sptr transport, flow_ctrl_func send_flow_ctrl, @@ -114,11 +114,11 @@ public: for (size_t i = 0; i < transport->get_num_send_frames(); i++) { _send_buffers[i] = - boost::make_shared<zero_copy_flow_ctrl_msb>(_send_flow_ctrl); + std::make_shared<zero_copy_flow_ctrl_msb>(_send_flow_ctrl); } for (size_t i = 0; i < transport->get_num_recv_frames(); i++) { _recv_buffers[i] = - boost::make_shared<zero_copy_flow_ctrl_mrb>(_recv_flow_ctrl); + std::make_shared<zero_copy_flow_ctrl_mrb>(_recv_flow_ctrl); } } @@ -133,7 +133,7 @@ public: managed_recv_buffer::sptr ptr; managed_recv_buffer::sptr buff = _transport->get_recv_buff(timeout); if (buff) { - boost::shared_ptr<zero_copy_flow_ctrl_mrb> mb = + std::shared_ptr<zero_copy_flow_ctrl_mrb> mb = _recv_buffers[_recv_buff_index++]; _recv_buff_index %= _recv_buffers.size(); ptr = mb->get(buff); @@ -160,7 +160,7 @@ public: managed_send_buffer::sptr ptr; managed_send_buffer::sptr buff = _transport->get_send_buff(timeout); if (buff) { - boost::shared_ptr<zero_copy_flow_ctrl_msb> mb = + std::shared_ptr<zero_copy_flow_ctrl_msb> mb = _send_buffers[_send_buff_index++]; _send_buff_index %= _send_buffers.size(); ptr = mb->get(buff); @@ -183,8 +183,8 @@ private: zero_copy_if::sptr _transport; // buffers - std::vector<boost::shared_ptr<zero_copy_flow_ctrl_msb>> _send_buffers; - std::vector<boost::shared_ptr<zero_copy_flow_ctrl_mrb>> _recv_buffers; + std::vector<std::shared_ptr<zero_copy_flow_ctrl_msb>> _send_buffers; + std::vector<std::shared_ptr<zero_copy_flow_ctrl_mrb>> _recv_buffers; size_t _send_buff_index; size_t _recv_buff_index; diff --git a/host/lib/types/filters_python.hpp b/host/lib/types/filters_python.hpp index ad13eed1e..be02c7a98 100644 --- a/host/lib/types/filters_python.hpp +++ b/host/lib/types/filters_python.hpp @@ -40,7 +40,7 @@ void export_filters(py::module& m) .def("get_analog_type", &analog_filter_base::get_analog_type) ; - py::class_<analog_filter_lp, boost::shared_ptr<analog_filter_lp>>(m, "analog_filter_lp") + py::class_<analog_filter_lp, std::shared_ptr<analog_filter_lp>>(m, "analog_filter_lp") .def(py::init<filter_info_type, bool, size_t, const std::string, double, double>()) // Methods diff --git a/host/lib/usrp/b100/b100_impl.hpp b/host/lib/usrp/b100/b100_impl.hpp index 492db5740..bb72cd63e 100644 --- a/host/lib/usrp/b100/b100_impl.hpp +++ b/host/lib/usrp/b100/b100_impl.hpp @@ -30,7 +30,7 @@ #include <uhdlib/usrp/cores/tx_dsp_core_200.hpp> #include <uhdlib/usrp/cores/time64_core_200.hpp> #include <uhdlib/usrp/cores/user_settings_core_200.hpp> -#include <boost/weak_ptr.hpp> +#include <memory> static const double B100_LINK_RATE_BPS = 256e6/5; //pratical link rate (< 480 Mbps) static const std::string B100_FW_FILE_NAME = "usrp_b100_fw.ihx"; @@ -112,14 +112,14 @@ private: //transports uhd::transport::zero_copy_if::sptr _ctrl_transport; uhd::transport::zero_copy_if::sptr _data_transport; - boost::shared_ptr<uhd::usrp::recv_packet_demuxer_3000> _recv_demuxer; + std::shared_ptr<uhd::usrp::recv_packet_demuxer_3000> _recv_demuxer; //dboard stuff uhd::usrp::dboard_manager::sptr _dboard_manager; bool _ignore_cal_file; - std::vector<boost::weak_ptr<uhd::rx_streamer> > _rx_streamers; - std::vector<boost::weak_ptr<uhd::tx_streamer> > _tx_streamers; + std::vector<std::weak_ptr<uhd::rx_streamer> > _rx_streamers; + std::vector<std::weak_ptr<uhd::tx_streamer> > _tx_streamers; void check_fw_compat(void); void check_fpga_compat(void); diff --git a/host/lib/usrp/b100/clock_ctrl.hpp b/host/lib/usrp/b100/clock_ctrl.hpp index a6f516e15..b208e8a0c 100644 --- a/host/lib/usrp/b100/clock_ctrl.hpp +++ b/host/lib/usrp/b100/clock_ctrl.hpp @@ -10,7 +10,7 @@ #include <uhd/types/serial.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <vector> /*! @@ -19,7 +19,7 @@ */ class b100_clock_ctrl : uhd::noncopyable{ public: - typedef boost::shared_ptr<b100_clock_ctrl> sptr; + typedef std::shared_ptr<b100_clock_ctrl> sptr; virtual ~b100_clock_ctrl(void) = 0; diff --git a/host/lib/usrp/b100/codec_ctrl.hpp b/host/lib/usrp/b100/codec_ctrl.hpp index 67a5f7e9c..5f77d00f9 100644 --- a/host/lib/usrp/b100/codec_ctrl.hpp +++ b/host/lib/usrp/b100/codec_ctrl.hpp @@ -11,7 +11,7 @@ #include <uhd/types/serial.hpp> #include <uhd/types/ranges.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> /*! * The B100 codec control: @@ -20,7 +20,7 @@ */ class b100_codec_ctrl : uhd::noncopyable{ public: - typedef boost::shared_ptr<b100_codec_ctrl> sptr; + typedef std::shared_ptr<b100_codec_ctrl> sptr; static const uhd::gain_range_t tx_pga_gain_range; static const uhd::gain_range_t rx_pga_gain_range; diff --git a/host/lib/usrp/b100/fifo_ctrl_excelsior.hpp b/host/lib/usrp/b100/fifo_ctrl_excelsior.hpp index 91c006a1a..27da0026c 100644 --- a/host/lib/usrp/b100/fifo_ctrl_excelsior.hpp +++ b/host/lib/usrp/b100/fifo_ctrl_excelsior.hpp @@ -12,7 +12,7 @@ #include <uhd/types/metadata.hpp> #include <uhd/types/serial.hpp> #include <uhd/transport/zero_copy.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/utility.hpp> #include <uhd/types/wb_iface.hpp> #include <string> @@ -33,7 +33,7 @@ struct fifo_ctrl_excelsior_config class fifo_ctrl_excelsior : public uhd::timed_wb_iface, public uhd::spi_iface { public: - typedef boost::shared_ptr<fifo_ctrl_excelsior> sptr; + typedef std::shared_ptr<fifo_ctrl_excelsior> sptr; //! Make a new control object static sptr make( diff --git a/host/lib/usrp/b100/io_impl.cpp b/host/lib/usrp/b100/io_impl.cpp index ed90b11ba..d3de1cca1 100644 --- a/host/lib/usrp/b100/io_impl.cpp +++ b/host/lib/usrp/b100/io_impl.cpp @@ -15,7 +15,7 @@ #include <boost/format.hpp> #include <boost/bind.hpp> #include <boost/thread.hpp> -#include <boost/make_shared.hpp> +#include <memory> using namespace uhd; using namespace uhd::usrp; @@ -38,22 +38,22 @@ void b100_impl::update_tick_rate(const double rate){ //update the tick rate on all existing streamers -> thread safe for (size_t i = 0; i < _rx_streamers.size(); i++){ - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>(_rx_streamers[i].lock()); + std::shared_ptr<sph::recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>(_rx_streamers[i].lock()); if (my_streamer.get() == NULL) continue; my_streamer->set_tick_rate(rate); } for (size_t i = 0; i < _tx_streamers.size(); i++){ - boost::shared_ptr<sph::send_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::send_packet_streamer>(_tx_streamers[i].lock()); + std::shared_ptr<sph::send_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::send_packet_streamer>(_tx_streamers[i].lock()); if (my_streamer.get() == NULL) continue; my_streamer->set_tick_rate(rate); } } void b100_impl::update_rx_samp_rate(const size_t dspno, const double rate){ - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>(_rx_streamers[dspno].lock()); + std::shared_ptr<sph::recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>(_rx_streamers[dspno].lock()); if (my_streamer.get() == NULL) return; my_streamer->set_samp_rate(rate); @@ -62,8 +62,8 @@ void b100_impl::update_rx_samp_rate(const size_t dspno, const double rate){ } void b100_impl::update_tx_samp_rate(const size_t dspno, const double rate){ - boost::shared_ptr<sph::send_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::send_packet_streamer>(_tx_streamers[dspno].lock()); + std::shared_ptr<sph::send_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::send_packet_streamer>(_tx_streamers[dspno].lock()); if (my_streamer.get() == NULL) return; my_streamer->set_samp_rate(rate); @@ -129,7 +129,7 @@ rx_streamer::sptr b100_impl::get_rx_stream(const uhd::stream_args_t &args_){ const size_t spp = unsigned(args.args.cast<double>("spp", bpp/bpi)); //make the new streamer given the samples per packet - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = boost::make_shared<sph::recv_packet_streamer>(spp); + std::shared_ptr<sph::recv_packet_streamer> my_streamer = std::make_shared<sph::recv_packet_streamer>(spp); //init some streamer stuff my_streamer->resize(args.channels.size()); @@ -188,7 +188,7 @@ tx_streamer::sptr b100_impl::get_tx_stream(const uhd::stream_args_t &args_){ const size_t spp = bpp/convert::get_bytes_per_item(args.otw_format); //make the new streamer given the samples per packet - boost::shared_ptr<sph::send_packet_streamer> my_streamer = boost::make_shared<sph::send_packet_streamer>(spp); + std::shared_ptr<sph::send_packet_streamer> my_streamer = std::make_shared<sph::send_packet_streamer>(spp); //init some streamer stuff my_streamer->resize(args.channels.size()); diff --git a/host/lib/usrp/b100/usb_zero_copy_wrapper.cpp b/host/lib/usrp/b100/usb_zero_copy_wrapper.cpp index 54c367077..6303c301d 100644 --- a/host/lib/usrp/b100/usb_zero_copy_wrapper.cpp +++ b/host/lib/usrp/b100/usb_zero_copy_wrapper.cpp @@ -11,7 +11,7 @@ #include <uhd/utils/log.hpp> #include <uhd/utils/tasks.hpp> #include <uhdlib/utils/atomic.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <boost/thread/mutex.hpp> #include <boost/thread/condition_variable.hpp> #include <boost/bind.hpp> @@ -161,9 +161,9 @@ public: _next_recv_buff_index(0) { for (size_t i = 0; i < this->get_num_recv_frames(); i++){ - _mrb_pool.push_back(boost::make_shared<usb_zero_copy_wrapper_mrb>()); + _mrb_pool.push_back(std::make_shared<usb_zero_copy_wrapper_mrb>()); } - _the_only_msb = boost::make_shared<usb_zero_copy_wrapper_msb>(usb_zc, frame_boundary); + _the_only_msb = std::make_shared<usb_zero_copy_wrapper_msb>(usb_zc, frame_boundary); } managed_recv_buffer::sptr get_recv_buff(double timeout){ @@ -211,8 +211,8 @@ public: private: zero_copy_if::sptr _internal_zc; size_t _frame_boundary; - std::vector<boost::shared_ptr<usb_zero_copy_wrapper_mrb> > _mrb_pool; - boost::shared_ptr<usb_zero_copy_wrapper_msb> _the_only_msb; + std::vector<std::shared_ptr<usb_zero_copy_wrapper_mrb> > _mrb_pool; + std::shared_ptr<usb_zero_copy_wrapper_msb> _the_only_msb; //state for last recv buffer to create multiple managed buffers managed_recv_buffer::sptr _last_recv_buff; diff --git a/host/lib/usrp/b200/b200_cores.hpp b/host/lib/usrp/b200/b200_cores.hpp index 7dabb66e9..324938a73 100644 --- a/host/lib/usrp/b200/b200_cores.hpp +++ b/host/lib/usrp/b200/b200_cores.hpp @@ -12,13 +12,13 @@ #include <uhd/utils/noncopyable.hpp> #include <uhdlib/usrp/cores/spi_core_3000.hpp> #include <uhdlib/usrp/common/adf4001_ctrl.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <mutex> class b200_local_spi_core : uhd::noncopyable, public uhd::spi_iface { public: - typedef boost::shared_ptr<b200_local_spi_core> sptr; + typedef std::shared_ptr<b200_local_spi_core> sptr; enum perif_t { CODEC, PLL @@ -47,7 +47,7 @@ private: class b200_ref_pll_ctrl : public uhd::usrp::adf4001_ctrl { public: - typedef boost::shared_ptr<b200_ref_pll_ctrl> sptr; + typedef std::shared_ptr<b200_ref_pll_ctrl> sptr; b200_ref_pll_ctrl(b200_local_spi_core::sptr spi); virtual void set_lock_to_ext_ref(bool external); diff --git a/host/lib/usrp/b200/b200_iface.hpp b/host/lib/usrp/b200/b200_iface.hpp index 4389d4eed..a3059bacf 100644 --- a/host/lib/usrp/b200/b200_iface.hpp +++ b/host/lib/usrp/b200/b200_iface.hpp @@ -13,7 +13,7 @@ #include <uhd/types/dict.hpp> #include <uhdlib/usrp/common/ad9361_ctrl.hpp> #include <boost/assign/list_of.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/utils/noncopyable.hpp> #include <stdint.h> @@ -79,7 +79,7 @@ static const uhd::dict<b200_product_t, std::string> B2XX_FPGA_FILE_NAME = boost: class UHD_API b200_iface: uhd::noncopyable, public virtual uhd::i2c_iface { public: - typedef boost::shared_ptr<b200_iface> sptr; + typedef std::shared_ptr<b200_iface> sptr; /*! * Make a b200 interface object from a control transport diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp index 1be8c263b..be21ade63 100644 --- a/host/lib/usrp/b200/b200_impl.cpp +++ b/host/lib/usrp/b200/b200_impl.cpp @@ -20,8 +20,7 @@ #include <boost/filesystem.hpp> #include <boost/lexical_cast.hpp> #include <boost/functional/hash.hpp> -#include <boost/make_shared.hpp> -#include <boost/weak_ptr.hpp> +#include <memory> #include <cstdio> #include <ctime> #include <cmath> @@ -255,7 +254,7 @@ static device::sptr b200_make(const device_addr_t &device_addr) catch (const uhd::usb_error &) { UHD_LOGGER_INFO("B200") << "Detected bad USB state; resetting." ; libusb::device_handle::sptr dev_handle(libusb::device_handle::get_cached_handle( - boost::static_pointer_cast<libusb::special_handle>(handle)->get_device() + std::static_pointer_cast<libusb::special_handle>(handle)->get_device() )); dev_handle->clear_endpoints(B200_USB_CTRL_RECV_ENDPOINT, B200_USB_CTRL_SEND_ENDPOINT); dev_handle->clear_endpoints(B200_USB_DATA_RECV_ENDPOINT, B200_USB_DATA_SEND_ENDPOINT); @@ -578,7 +577,7 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s //////////////////////////////////////////////////////////////////// _spi_iface = b200_local_spi_core::make(_local_ctrl); if (not (_product == B200MINI or _product == B205MINI)) { - _adf4001_iface = boost::make_shared<b200_ref_pll_ctrl>(_spi_iface); + _adf4001_iface = std::make_shared<b200_ref_pll_ctrl>(_spi_iface); } //////////////////////////////////////////////////////////////////// @@ -588,9 +587,9 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s reset_codec(); ad9361_params::sptr client_settings; if (_product == B200MINI or _product == B205MINI) { - client_settings = boost::make_shared<b2xxmini_ad9361_client_t>(); + client_settings = std::make_shared<b2xxmini_ad9361_client_t>(); } else { - client_settings = boost::make_shared<b200_ad9361_client_t>(); + client_settings = std::make_shared<b200_ad9361_client_t>(); } _codec_ctrl = ad9361_ctrl::make_spi(client_settings, _spi_iface, AD9361_SLAVENO); diff --git a/host/lib/usrp/b200/b200_impl.hpp b/host/lib/usrp/b200/b200_impl.hpp index 6e777d4d6..bd44aa14f 100644 --- a/host/lib/usrp/b200/b200_impl.hpp +++ b/host/lib/usrp/b200/b200_impl.hpp @@ -36,8 +36,8 @@ #include <uhdlib/usrp/common/ad936x_manager.hpp> #include <uhdlib/usrp/common/adf4001_ctrl.hpp> #include <boost/assign.hpp> -#include <boost/weak_ptr.hpp> #include <mutex> +#include <memory> static const uint8_t B200_FW_COMPAT_NUM_MAJOR = 8; static const uint8_t B200_FW_COMPAT_NUM_MINOR = 0; @@ -138,7 +138,7 @@ private: uhd::usrp::ad9361_ctrl::sptr _codec_ctrl; uhd::usrp::ad936x_manager::sptr _codec_mgr; b200_local_spi_core::sptr _spi_iface; - boost::shared_ptr<uhd::usrp::adf4001_ctrl> _adf4001_iface; + std::shared_ptr<uhd::usrp::adf4001_ctrl> _adf4001_iface; uhd::gps_ctrl::sptr _gps; //transports @@ -146,8 +146,8 @@ private: uhd::transport::zero_copy_if::sptr _ctrl_transport; uhd::usrp::recv_packet_demuxer_3000::sptr _demux; - boost::weak_ptr<uhd::rx_streamer> _rx_streamer; - boost::weak_ptr<uhd::tx_streamer> _tx_streamer; + std::weak_ptr<uhd::rx_streamer> _rx_streamer; + std::weak_ptr<uhd::tx_streamer> _tx_streamer; std::mutex _transport_setup_mutex; @@ -156,13 +156,13 @@ private: typedef uhd::transport::bounded_buffer<uhd::async_metadata_t> async_md_type; struct AsyncTaskData { - boost::shared_ptr<async_md_type> async_md; - boost::weak_ptr<radio_ctrl_core_3000> local_ctrl; - boost::weak_ptr<radio_ctrl_core_3000> radio_ctrl[2]; + std::shared_ptr<async_md_type> async_md; + std::weak_ptr<radio_ctrl_core_3000> local_ctrl; + std::weak_ptr<radio_ctrl_core_3000> radio_ctrl[2]; b200_uart::sptr gpsdo_uart; }; - boost::shared_ptr<AsyncTaskData> _async_task_data; - boost::optional<uhd::msg_task::msg_type_t> handle_async_task(uhd::transport::zero_copy_if::sptr, boost::shared_ptr<AsyncTaskData>); + std::shared_ptr<AsyncTaskData> _async_task_data; + boost::optional<uhd::msg_task::msg_type_t> handle_async_task(uhd::transport::zero_copy_if::sptr, std::shared_ptr<AsyncTaskData>); void register_loopback_self_test(uhd::wb_iface::sptr iface); void set_mb_eeprom(const uhd::usrp::mboard_eeprom_t &); @@ -191,8 +191,8 @@ private: rx_dsp_core_3000::sptr ddc; tx_vita_core_3000::sptr deframer; tx_dsp_core_3000::sptr duc; - boost::weak_ptr<uhd::rx_streamer> rx_streamer; - boost::weak_ptr<uhd::tx_streamer> tx_streamer; + std::weak_ptr<uhd::rx_streamer> rx_streamer; + std::weak_ptr<uhd::tx_streamer> tx_streamer; user_settings_core_3000::sptr user_settings; bool ant_rx2; }; diff --git a/host/lib/usrp/b200/b200_io_impl.cpp b/host/lib/usrp/b200/b200_io_impl.cpp index 5a0de430f..88cde6071 100644 --- a/host/lib/usrp/b200/b200_io_impl.cpp +++ b/host/lib/usrp/b200/b200_io_impl.cpp @@ -13,7 +13,7 @@ #include <uhdlib/usrp/common/async_packet_handler.hpp> #include <uhdlib/usrp/common/validate_subdev_spec.hpp> #include <boost/bind.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <set> using namespace uhd; @@ -37,15 +37,15 @@ size_t b200_impl::max_chan_count(const std::string& direction /* = "" */) for (radio_perifs_t& perif : _radio_perifs) { if ((direction == "RX" or direction.empty()) and not perif.rx_streamer.expired()) { - boost::shared_ptr<sph::recv_packet_streamer> rx_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>( + std::shared_ptr<sph::recv_packet_streamer> rx_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>( perif.rx_streamer.lock()); max_count = std::max(max_count, rx_streamer->get_num_channels()); } if ((direction == "TX" or direction.empty()) and not perif.tx_streamer.expired()) { - boost::shared_ptr<sph::send_packet_streamer> tx_streamer = - boost::dynamic_pointer_cast<sph::send_packet_streamer>( + std::shared_ptr<sph::send_packet_streamer> tx_streamer = + std::dynamic_pointer_cast<sph::send_packet_streamer>( perif.tx_streamer.lock()); max_count = std::max(max_count, tx_streamer->get_num_channels()); } @@ -142,16 +142,16 @@ void b200_impl::update_tick_rate(const double new_tick_rate) check_tick_rate_with_current_streamers(new_tick_rate); for (radio_perifs_t& perif : _radio_perifs) { - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>( + std::shared_ptr<sph::recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>( perif.rx_streamer.lock()); if (my_streamer) my_streamer->set_tick_rate(new_tick_rate); perif.framer->set_tick_rate(new_tick_rate); } for (radio_perifs_t& perif : _radio_perifs) { - boost::shared_ptr<sph::send_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::send_packet_streamer>( + std::shared_ptr<sph::send_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::send_packet_streamer>( perif.tx_streamer.lock()); if (my_streamer) my_streamer->set_tick_rate(new_tick_rate); @@ -204,8 +204,8 @@ double b200_impl::coerce_rx_samp_rate( void b200_impl::update_rx_samp_rate(const size_t dspno, const double rate) { - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>( + std::shared_ptr<sph::recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>( _radio_perifs[dspno].rx_streamer.lock()); if (not my_streamer) return; @@ -231,8 +231,8 @@ double b200_impl::coerce_tx_samp_rate( void b200_impl::update_tx_samp_rate(const size_t dspno, const double rate) { - boost::shared_ptr<sph::send_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::send_packet_streamer>( + std::shared_ptr<sph::send_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::send_packet_streamer>( _radio_perifs[dspno].tx_streamer.lock()); if (not my_streamer) return; @@ -314,7 +314,7 @@ bool b200_impl::recv_async_msg(async_metadata_t& async_metadata, double timeout) * there. */ boost::optional<uhd::msg_task::msg_type_t> b200_impl::handle_async_task( - uhd::transport::zero_copy_if::sptr xport, boost::shared_ptr<AsyncTaskData> data) + uhd::transport::zero_copy_if::sptr xport, std::shared_ptr<AsyncTaskData> data) { managed_recv_buffer::sptr buff = xport->get_recv_buff(); if (not buff or buff->size() < 8) @@ -405,7 +405,7 @@ rx_streamer::sptr b200_impl::get_rx_stream(const uhd::stream_args_t& args_) } check_streamer_args(args, this->get_tick_rate(), "RX"); - boost::shared_ptr<sph::recv_packet_streamer> my_streamer; + std::shared_ptr<sph::recv_packet_streamer> my_streamer; for (size_t stream_i = 0; stream_i < args.channels.size(); stream_i++) { const size_t radio_index = _tree->access<std::vector<size_t>>("/mboards/0/rx_chan_dsp_mapping") @@ -437,7 +437,7 @@ rx_streamer::sptr b200_impl::get_rx_stream(const uhd::stream_args_t& args_) // make the new streamer given the samples per packet if (not my_streamer) - my_streamer = boost::make_shared<sph::recv_packet_streamer>(spp); + my_streamer = std::make_shared<sph::recv_packet_streamer>(spp); my_streamer->resize(args.channels.size()); // init some streamer stuff @@ -480,8 +480,8 @@ rx_streamer::sptr b200_impl::get_rx_stream(const uhd::stream_args_t& args_) void b200_impl::handle_overflow(const size_t radio_index) { - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>( + std::shared_ptr<sph::recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>( _radio_perifs[radio_index].rx_streamer.lock()); if (my_streamer->get_num_channels() == 2) // MIMO time { @@ -527,7 +527,7 @@ tx_streamer::sptr b200_impl::get_tx_stream(const uhd::stream_args_t& args_) } check_streamer_args(args, this->get_tick_rate(), "TX"); - boost::shared_ptr<sph::send_packet_streamer> my_streamer; + std::shared_ptr<sph::send_packet_streamer> my_streamer; for (size_t stream_i = 0; stream_i < args.channels.size(); stream_i++) { const size_t radio_index = _tree->access<std::vector<size_t>>("/mboards/0/tx_chan_dsp_mapping") @@ -556,7 +556,7 @@ tx_streamer::sptr b200_impl::get_tx_stream(const uhd::stream_args_t& args_) // make the new streamer given the samples per packet if (not my_streamer) - my_streamer = boost::make_shared<sph::send_packet_streamer>(spp); + my_streamer = std::make_shared<sph::send_packet_streamer>(spp); my_streamer->resize(args.channels.size()); // init some streamer stuff diff --git a/host/lib/usrp/b200/b200_uart.hpp b/host/lib/usrp/b200/b200_uart.hpp index 25dc1171e..c6de5f844 100644 --- a/host/lib/usrp/b200/b200_uart.hpp +++ b/host/lib/usrp/b200/b200_uart.hpp @@ -12,12 +12,12 @@ #include <uhd/transport/zero_copy.hpp> #include <uhd/types/serial.hpp> //uart iface #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> class b200_uart: uhd::noncopyable, public uhd::uart_iface { public: - typedef boost::shared_ptr<b200_uart> sptr; + typedef std::shared_ptr<b200_uart> sptr; static sptr make(uhd::transport::zero_copy_if::sptr, const uint32_t sid); virtual void handle_uart_packet(uhd::transport::managed_recv_buffer::sptr buff) = 0; }; diff --git a/host/lib/usrp/common/ad9361_ctrl.cpp b/host/lib/usrp/common/ad9361_ctrl.cpp index b89ec2d32..8e57c48c9 100644 --- a/host/lib/usrp/common/ad9361_ctrl.cpp +++ b/host/lib/usrp/common/ad9361_ctrl.cpp @@ -10,7 +10,7 @@ #include <uhd/utils/log.hpp> #include <uhdlib/usrp/common/ad9361_ctrl.hpp> #include <boost/format.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <cstring> #include <mutex> @@ -325,8 +325,8 @@ ad9361_ctrl::sptr ad9361_ctrl::make_spi(ad9361_params::sptr client_settings, uhd::spi_iface::sptr spi_iface, uint32_t slave_num) { - boost::shared_ptr<ad9361_io_spi> spi_io_iface = - boost::make_shared<ad9361_io_spi>(spi_iface, slave_num); + std::shared_ptr<ad9361_io_spi> spi_io_iface = + std::make_shared<ad9361_io_spi>(spi_iface, slave_num); return sptr(new ad9361_ctrl_impl(client_settings, spi_io_iface)); } diff --git a/host/lib/usrp/common/ad9361_driver/ad9361_client.h b/host/lib/usrp/common/ad9361_driver/ad9361_client.h index a2343a3db..e8201825a 100644 --- a/host/lib/usrp/common/ad9361_driver/ad9361_client.h +++ b/host/lib/usrp/common/ad9361_driver/ad9361_client.h @@ -8,7 +8,7 @@ #ifndef INCLUDED_AD9361_CLIENT_H #define INCLUDED_AD9361_CLIENT_H -#include <boost/shared_ptr.hpp> +#include <memory> namespace uhd { namespace usrp { @@ -49,7 +49,7 @@ typedef struct { class ad9361_params { public: - typedef boost::shared_ptr<ad9361_params> sptr; + typedef std::shared_ptr<ad9361_params> sptr; virtual ~ad9361_params() {} @@ -62,7 +62,7 @@ public: class ad9361_io { public: - typedef boost::shared_ptr<ad9361_io> sptr; + typedef std::shared_ptr<ad9361_io> sptr; virtual ~ad9361_io() {} diff --git a/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp b/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp index a3d3552ef..44b650f52 100644 --- a/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp +++ b/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp @@ -2733,8 +2733,8 @@ filter_info_base::sptr ad9361_device_t::_get_filter_hb_2(direction_t direction) int16_t taps_array[] = {-9, 0, 73, 128, 73, 0, -9}; std::vector<int16_t> taps(taps_array, taps_array + sizeof(taps_array) / sizeof(int16_t) ); - digital_filter_base<int16_t>::sptr hb_3 = boost::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_hb_3(direction)); - digital_filter_base<int16_t>::sptr dec_int_3 = boost::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_dec_int_3(direction)); + digital_filter_base<int16_t>::sptr hb_3 = std::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_hb_3(direction)); + digital_filter_base<int16_t>::sptr dec_int_3 = std::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_dec_int_3(direction)); if(direction == RX) { @@ -2791,7 +2791,7 @@ filter_info_base::sptr ad9361_device_t::_get_filter_hb_1(direction_t direction) int16_t taps_rx_array[] = {-8, 0, 42, 0, -147, 0, 619, 1013, 619, 0, -147, 0, 42, 0, -8}; int16_t taps_tx_array[] = {-53, 0, 313, 0, -1155, 0, 4989, 8192, 4989, 0, -1155, 0, 313, 0, -53}; - digital_filter_base<int16_t>::sptr hb_2 = boost::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_hb_2(direction)); + digital_filter_base<int16_t>::sptr hb_2 = std::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_hb_2(direction)); if(direction == RX) { @@ -2826,7 +2826,7 @@ filter_info_base::sptr ad9361_device_t::_get_filter_fir(direction_t direction, c size_t max_num_taps = 128; uint8_t enable = 1; - digital_filter_base<int16_t>::sptr hb_1 = boost::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_hb_1(direction)); + digital_filter_base<int16_t>::sptr hb_1 = std::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_hb_1(direction)); if(direction == RX) { @@ -2861,7 +2861,7 @@ filter_info_base::sptr ad9361_device_t::_get_filter_fir(direction_t direction, c void ad9361_device_t::_set_filter_fir(direction_t direction, chain_t channel, filter_info_base::sptr filter) { - digital_filter_fir<int16_t>::sptr fir = boost::dynamic_pointer_cast<digital_filter_fir<int16_t> >(filter); + digital_filter_fir<int16_t>::sptr fir = std::dynamic_pointer_cast<digital_filter_fir<int16_t> >(filter); //only write taps. Ignore everything else for now _set_fir_taps(direction, channel, fir->get_taps()); } @@ -2873,7 +2873,7 @@ void ad9361_device_t::_set_filter_fir(direction_t direction, chain_t channel, fi */ void ad9361_device_t::_set_filter_lp_bb(direction_t direction, filter_info_base::sptr filter) { - analog_filter_lp::sptr lpf = boost::dynamic_pointer_cast<analog_filter_lp>(filter); + analog_filter_lp::sptr lpf = std::dynamic_pointer_cast<analog_filter_lp>(filter); double bw = lpf->get_cutoff(); if(direction == RX) { @@ -2888,7 +2888,7 @@ void ad9361_device_t::_set_filter_lp_bb(direction_t direction, filter_info_base: void ad9361_device_t::_set_filter_lp_tia_sec(direction_t direction, filter_info_base::sptr filter) { - analog_filter_lp::sptr lpf = boost::dynamic_pointer_cast<analog_filter_lp>(filter); + analog_filter_lp::sptr lpf = std::dynamic_pointer_cast<analog_filter_lp>(filter); double bw = lpf->get_cutoff(); if(direction == RX) { diff --git a/host/lib/usrp/common/ad936x_manager.cpp b/host/lib/usrp/common/ad936x_manager.cpp index 5c4cb51ae..b57b94302 100644 --- a/host/lib/usrp/common/ad936x_manager.cpp +++ b/host/lib/usrp/common/ad936x_manager.cpp @@ -8,7 +8,7 @@ #include <uhd/utils/log.hpp> #include <uhdlib/usrp/common/ad936x_manager.hpp> #include <boost/functional/hash.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <chrono> #include <cmath> #include <thread> @@ -329,5 +329,5 @@ private: ad936x_manager::sptr ad936x_manager::make( const ad9361_ctrl::sptr& codec_ctrl, const size_t n_frontends) { - return boost::make_shared<ad936x_manager_impl>(codec_ctrl, n_frontends); + return std::make_shared<ad936x_manager_impl>(codec_ctrl, n_frontends); } diff --git a/host/lib/usrp/cores/spi_core_3000.cpp b/host/lib/usrp/cores/spi_core_3000.cpp index ea476879b..fb9d9d549 100644 --- a/host/lib/usrp/cores/spi_core_3000.cpp +++ b/host/lib/usrp/cores/spi_core_3000.cpp @@ -8,7 +8,7 @@ #include <uhd/exception.hpp> #include <uhdlib/usrp/cores/spi_core_3000.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <chrono> #include <mutex> #include <thread> @@ -128,7 +128,7 @@ private: spi_core_3000::sptr spi_core_3000::make( wb_iface::sptr iface, const size_t base, const size_t readback) { - return boost::make_shared<spi_core_3000_impl>( + return std::make_shared<spi_core_3000_impl>( [iface]( const uint32_t addr, const uint32_t value) { iface->poke32(addr, value); }, [iface](const uint32_t addr) { return iface->peek32(addr); }, @@ -143,6 +143,6 @@ spi_core_3000::sptr spi_core_3000::make(spi_core_3000::poke32_fn_t&& poke32_fn, const size_t reg_offset, const size_t readback) { - return boost::make_shared<spi_core_3000_impl>( + return std::make_shared<spi_core_3000_impl>( std::move(poke32_fn), std::move(peek32_fn), base, reg_offset, readback); } diff --git a/host/lib/usrp/dboard/db_sbx_common.hpp b/host/lib/usrp/dboard/db_sbx_common.hpp index 4d463603f..9c09f21a3 100644 --- a/host/lib/usrp/dboard/db_sbx_common.hpp +++ b/host/lib/usrp/dboard/db_sbx_common.hpp @@ -272,7 +272,7 @@ protected: * sbx_version* subclass, and invoke any relevant functions through that * object. This pointer is set to the proper object at construction time. */ - typedef boost::shared_ptr<sbx_versionx> sbx_versionx_sptr; + typedef std::shared_ptr<sbx_versionx> sbx_versionx_sptr; sbx_versionx_sptr db_actual; }; diff --git a/host/lib/usrp/dboard/db_twinrx.cpp b/host/lib/usrp/dboard/db_twinrx.cpp index de1cd3f33..5a8fefeb7 100644 --- a/host/lib/usrp/dboard/db_twinrx.cpp +++ b/host/lib/usrp/dboard/db_twinrx.cpp @@ -19,7 +19,7 @@ #include <uhd/utils/log.hpp> #include <uhd/utils/static.hpp> #include "dboard_ctor_args.hpp" -#include <boost/make_shared.hpp> +#include <memory> #include <boost/thread.hpp> #include <boost/thread/mutex.hpp> //#include <fstream> //Needed for _expert->to_dot() below @@ -229,13 +229,13 @@ private: class twinrx_rcvr : public rx_dboard_base { public: - typedef boost::shared_ptr<twinrx_rcvr> sptr; + typedef std::shared_ptr<twinrx_rcvr> sptr; twinrx_rcvr(ctor_args_t args) : rx_dboard_base(args) { _db_iface = get_iface(); - twinrx_gpio::sptr gpio_iface = boost::make_shared<twinrx_gpio>(_db_iface); - twinrx_cpld_regmap::sptr cpld_regs = boost::make_shared<twinrx_cpld_regmap>(); + twinrx_gpio::sptr gpio_iface = std::make_shared<twinrx_gpio>(_db_iface); + twinrx_cpld_regmap::sptr cpld_regs = std::make_shared<twinrx_cpld_regmap>(); cpld_regs->initialize(*gpio_iface, false); _ctrl = twinrx_ctrl::make(_db_iface, gpio_iface, cpld_regs, get_rx_id()); _expert = expert_factory::create_container("twinrx_expert"); @@ -304,7 +304,7 @@ public: static dboard_base::sptr make_twinrx_fe(dboard_base::ctor_args_t args) { const dboard_ctor_args_t& db_args = dboard_ctor_args_t::cast(args); - sptr container = boost::dynamic_pointer_cast<twinrx_rcvr>(db_args.rx_container); + sptr container = std::dynamic_pointer_cast<twinrx_rcvr>(db_args.rx_container); if (container) { dboard_base::sptr fe = dboard_base::sptr( new twinrx_rcvr_fe(args, container->get_expert(), container->get_ctrl())); diff --git a/host/lib/usrp/dboard/db_ubx.cpp b/host/lib/usrp/dboard/db_ubx.cpp index 305a69c52..72b3e331d 100644 --- a/host/lib/usrp/dboard/db_ubx.cpp +++ b/host/lib/usrp/dboard/db_ubx.cpp @@ -20,7 +20,7 @@ #include <uhd/utils/safe_call.hpp> #include <uhdlib/usrp/common/max287x.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/math/special_functions/round.hpp> #include <boost/algorithm/string.hpp> #include <boost/thread/mutex.hpp> @@ -1329,10 +1329,10 @@ private: ubx_cpld_reg_t _cpld_reg; uint32_t _prev_cpld_value; std::map<ubx_gpio_field_id_t,ubx_gpio_field_info_t> _gpio_map; - boost::shared_ptr<max287x_iface> _txlo1; - boost::shared_ptr<max287x_iface> _txlo2; - boost::shared_ptr<max287x_iface> _rxlo1; - boost::shared_ptr<max287x_iface> _rxlo2; + std::shared_ptr<max287x_iface> _txlo1; + std::shared_ptr<max287x_iface> _txlo2; + std::shared_ptr<max287x_iface> _rxlo1; + std::shared_ptr<max287x_iface> _rxlo2; double _tx_target_pfd_freq; double _rx_target_pfd_freq; double _tx_gain; diff --git a/host/lib/usrp/dboard/db_wbx_common.hpp b/host/lib/usrp/dboard/db_wbx_common.hpp index ea012c91c..ec6459583 100644 --- a/host/lib/usrp/dboard/db_wbx_common.hpp +++ b/host/lib/usrp/dboard/db_wbx_common.hpp @@ -61,7 +61,7 @@ #include <uhd/usrp/dboard_base.hpp> #include <boost/assign/list_of.hpp> #include <boost/format.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/math/special_functions/round.hpp> #include <boost/bind.hpp> @@ -200,7 +200,7 @@ protected: * wbx_version_* subclass, and invoke any relevant functions through that * object. This pointer is set to the proper object at construction time. */ - typedef boost::shared_ptr<wbx_versionx> wbx_versionx_sptr; + typedef std::shared_ptr<wbx_versionx> wbx_versionx_sptr; wbx_versionx_sptr db_actual; uhd::dict<std::string, double> _tx_gains, _rx_gains; diff --git a/host/lib/usrp/dboard/magnesium/magnesium_cpld_ctrl.hpp b/host/lib/usrp/dboard/magnesium/magnesium_cpld_ctrl.hpp index 05455e3fd..8f4ee0caa 100644 --- a/host/lib/usrp/dboard/magnesium/magnesium_cpld_ctrl.hpp +++ b/host/lib/usrp/dboard/magnesium/magnesium_cpld_ctrl.hpp @@ -1,5 +1,6 @@ // // Copyright 2017 Ettus Research, a National Instruments Company +// Copyright 2019 Ettus Research, a National Instruments Brand // // SPDX-License-Identifier: GPL-3.0-or-later // @@ -12,6 +13,7 @@ #include <uhd/types/serial.hpp> #include <memory> #include <mutex> +#include <functional> //! Controls the CPLD on a Magnesium daughterboard // diff --git a/host/lib/usrp/dboard/magnesium/magnesium_radio_control.cpp b/host/lib/usrp/dboard/magnesium/magnesium_radio_control.cpp index 13186e146..32c16adc6 100644 --- a/host/lib/usrp/dboard/magnesium/magnesium_radio_control.cpp +++ b/host/lib/usrp/dboard/magnesium/magnesium_radio_control.cpp @@ -18,7 +18,7 @@ #include <uhd/rfnoc/registry.hpp> #include <boost/algorithm/string.hpp> #include <boost/format.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <cmath> #include <cstdlib> #include <sstream> diff --git a/host/lib/usrp/dboard/magnesium/magnesium_radio_control_init.cpp b/host/lib/usrp/dboard/magnesium/magnesium_radio_control_init.cpp index d8a1ccba8..a1b039079 100644 --- a/host/lib/usrp/dboard/magnesium/magnesium_radio_control_init.cpp +++ b/host/lib/usrp/dboard/magnesium/magnesium_radio_control_init.cpp @@ -14,7 +14,7 @@ #include <boost/algorithm/string.hpp> #include <boost/algorithm/string/case_conv.hpp> #include <boost/algorithm/string/split.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <string> #include <vector> diff --git a/host/lib/usrp/dboard/rhodium/rhodium_radio_control.cpp b/host/lib/usrp/dboard/rhodium/rhodium_radio_control.cpp index df2c3aadd..54c6333bc 100644 --- a/host/lib/usrp/dboard/rhodium/rhodium_radio_control.cpp +++ b/host/lib/usrp/dboard/rhodium/rhodium_radio_control.cpp @@ -18,7 +18,7 @@ #include <uhdlib/utils/narrow.hpp> #include <boost/algorithm/string.hpp> #include <boost/format.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <cmath> #include <cstdlib> #include <sstream> diff --git a/host/lib/usrp/dboard/rhodium/rhodium_radio_control.hpp b/host/lib/usrp/dboard/rhodium/rhodium_radio_control.hpp index a70db79cc..8cee33f17 100644 --- a/host/lib/usrp/dboard/rhodium/rhodium_radio_control.hpp +++ b/host/lib/usrp/dboard/rhodium/rhodium_radio_control.hpp @@ -29,7 +29,7 @@ namespace uhd { namespace rfnoc { class rhodium_radio_control_impl : public radio_control_impl { public: - typedef boost::shared_ptr<rhodium_radio_control_impl> sptr; + typedef std::shared_ptr<rhodium_radio_control_impl> sptr; //! Frequency bands for RX. Bands are a function of the analog filter banks enum class rx_band { diff --git a/host/lib/usrp/dboard/twinrx/twinrx_io.hpp b/host/lib/usrp/dboard/twinrx/twinrx_io.hpp index ea1f1150a..e3e475148 100644 --- a/host/lib/usrp/dboard/twinrx/twinrx_io.hpp +++ b/host/lib/usrp/dboard/twinrx/twinrx_io.hpp @@ -41,7 +41,7 @@ static uint32_t get_reg(wb_iface::wb_addr_type addr) { class twinrx_gpio : public wb_iface { public: - typedef boost::shared_ptr<twinrx_gpio> sptr; + typedef std::shared_ptr<twinrx_gpio> sptr; //---------------------------------------------- //Public GPIO fields @@ -123,7 +123,7 @@ private: //Members/definitions class twinrx_cpld_regmap : public uhd::soft_regmap_t { public: - typedef boost::shared_ptr<twinrx_cpld_regmap> sptr; + typedef std::shared_ptr<twinrx_cpld_regmap> sptr; //---------------------------------------------- // IF CCA: CPLD 1 diff --git a/host/lib/usrp/mpmd/mpmd_impl.cpp b/host/lib/usrp/mpmd/mpmd_impl.cpp index 69f990807..cb463b3f4 100644 --- a/host/lib/usrp/mpmd/mpmd_impl.cpp +++ b/host/lib/usrp/mpmd/mpmd_impl.cpp @@ -10,7 +10,7 @@ #include <uhd/utils/static.hpp> #include <uhd/utils/tasks.hpp> #include <boost/algorithm/string.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <boost/thread.hpp> #include <chrono> #include <future> @@ -244,7 +244,7 @@ void mpmd_impl::setup_mb(mpmd_mboard_impl* mb, const size_t mb_index) ****************************************************************************/ static device::sptr mpmd_make(const device_addr_t& device_args) { - return device::sptr(boost::make_shared<mpmd_impl>(device_args)); + return device::sptr(std::make_shared<mpmd_impl>(device_args)); } UHD_STATIC_BLOCK(register_mpmd_device) diff --git a/host/lib/usrp/multi_usrp.cpp b/host/lib/usrp/multi_usrp.cpp index 6f8b794ce..4c6372fd5 100644 --- a/host/lib/usrp/multi_usrp.cpp +++ b/host/lib/usrp/multi_usrp.cpp @@ -24,7 +24,7 @@ #include <boost/assign/list_of.hpp> #include <boost/format.hpp> #include <boost/algorithm/string.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <algorithm> #include <cmath> #include <bitset> @@ -2510,9 +2510,9 @@ multi_usrp::sptr multi_usrp::make(const device_addr_t& dev_addr) device::sptr dev = device::make(dev_addr, device::USRP); - auto rfnoc_dev = boost::dynamic_pointer_cast<rfnoc::detail::rfnoc_device>(dev); + auto rfnoc_dev = std::dynamic_pointer_cast<rfnoc::detail::rfnoc_device>(dev); if (rfnoc_dev) { return rfnoc::detail::make_rfnoc_device(rfnoc_dev, dev_addr); } - return boost::make_shared<multi_usrp_impl>(dev); + return std::make_shared<multi_usrp_impl>(dev); } diff --git a/host/lib/usrp/multi_usrp_rfnoc.cpp b/host/lib/usrp/multi_usrp_rfnoc.cpp index 757872632..d7bc49639 100644 --- a/host/lib/usrp/multi_usrp_rfnoc.cpp +++ b/host/lib/usrp/multi_usrp_rfnoc.cpp @@ -15,10 +15,10 @@ #include <uhdlib/rfnoc/rfnoc_device.hpp> #include <uhdlib/usrp/gpio_defs.hpp> #include <unordered_set> -#include <boost/make_shared.hpp> #include <boost/pointer_cast.hpp> #include <algorithm> #include <chrono> +#include <memory> #include <mutex> #include <thread> #include <vector> @@ -2211,7 +2211,7 @@ multi_usrp::sptr make_rfnoc_device( detail::rfnoc_device::sptr rfnoc_device, const uhd::device_addr_t& dev_addr) { auto graph = uhd::rfnoc::detail::make_rfnoc_graph(rfnoc_device, dev_addr); - return boost::make_shared<multi_usrp_rfnoc>(graph, dev_addr); + return std::make_shared<multi_usrp_rfnoc>(graph, dev_addr); } }}} // namespace uhd::rfnoc::detail diff --git a/host/lib/usrp/usrp1/codec_ctrl.hpp b/host/lib/usrp/usrp1/codec_ctrl.hpp index dd038fb82..c03947673 100644 --- a/host/lib/usrp/usrp1/codec_ctrl.hpp +++ b/host/lib/usrp/usrp1/codec_ctrl.hpp @@ -11,7 +11,7 @@ #include <uhd/types/serial.hpp> #include <uhd/types/ranges.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> /*! * The usrp1 codec control: @@ -20,7 +20,7 @@ */ class usrp1_codec_ctrl : uhd::noncopyable{ public: - typedef boost::shared_ptr<usrp1_codec_ctrl> sptr; + typedef std::shared_ptr<usrp1_codec_ctrl> sptr; static const uhd::gain_range_t tx_pga_gain_range; static const uhd::gain_range_t rx_pga_gain_range; diff --git a/host/lib/usrp/usrp1/io_impl.cpp b/host/lib/usrp/usrp1/io_impl.cpp index 3ccfa11c9..3d45824e4 100644 --- a/host/lib/usrp/usrp1/io_impl.cpp +++ b/host/lib/usrp/usrp1/io_impl.cpp @@ -21,7 +21,7 @@ #include <boost/thread/thread.hpp> #include <boost/bind.hpp> #include <boost/format.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <atomic> #include <chrono> #include <thread> @@ -508,8 +508,8 @@ double usrp1_impl::update_rx_samp_rate(size_t dspno, const double samp_rate){ this->restore_rx(s); //update the streamer if created - boost::shared_ptr<usrp1_recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<usrp1_recv_packet_streamer>(_rx_streamer.lock()); + std::shared_ptr<usrp1_recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<usrp1_recv_packet_streamer>(_rx_streamer.lock()); if (my_streamer.get() != NULL){ my_streamer->set_samp_rate(_master_clock_rate / rate); } @@ -530,8 +530,8 @@ double usrp1_impl::update_tx_samp_rate(size_t dspno, const double samp_rate){ this->restore_tx(s); //update the streamer if created - boost::shared_ptr<usrp1_send_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<usrp1_send_packet_streamer>(_tx_streamer.lock()); + std::shared_ptr<usrp1_send_packet_streamer> my_streamer = + std::dynamic_pointer_cast<usrp1_send_packet_streamer>(_tx_streamer.lock()); if (my_streamer.get() != NULL){ my_streamer->set_samp_rate(_master_clock_rate / rate); } @@ -631,8 +631,8 @@ rx_streamer::sptr usrp1_impl::get_rx_stream(const uhd::stream_args_t &args_){ const size_t spp = bpp/convert::get_bytes_per_item(args.otw_format); //make the new streamer given the samples per packet - boost::shared_ptr<usrp1_recv_packet_streamer> my_streamer = - boost::make_shared<usrp1_recv_packet_streamer>(spp, _soft_time_ctrl); + std::shared_ptr<usrp1_recv_packet_streamer> my_streamer = + std::make_shared<usrp1_recv_packet_streamer>(spp, _soft_time_ctrl); //init some streamer stuff my_streamer->set_tick_rate(_master_clock_rate); @@ -688,8 +688,8 @@ tx_streamer::sptr usrp1_impl::get_tx_stream(const uhd::stream_args_t &args_){ //make the new streamer given the samples per packet boost::function<void(bool)> tx_fcn = boost::bind(&usrp1_impl::tx_stream_on_off, this, _1); - boost::shared_ptr<usrp1_send_packet_streamer> my_streamer = - boost::make_shared<usrp1_send_packet_streamer>(spp, _soft_time_ctrl, tx_fcn); + std::shared_ptr<usrp1_send_packet_streamer> my_streamer = + std::make_shared<usrp1_send_packet_streamer>(spp, _soft_time_ctrl, tx_fcn); //init some streamer stuff my_streamer->set_tick_rate(_master_clock_rate); diff --git a/host/lib/usrp/usrp1/soft_time_ctrl.cpp b/host/lib/usrp/usrp1/soft_time_ctrl.cpp index 7f39caf8a..92031136d 100644 --- a/host/lib/usrp/usrp1/soft_time_ctrl.cpp +++ b/host/lib/usrp/usrp1/soft_time_ctrl.cpp @@ -8,7 +8,7 @@ #include "soft_time_ctrl.hpp" #include <uhdlib/utils/system_time.hpp> #include <uhd/utils/tasks.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <boost/thread/condition_variable.hpp> #include <boost/date_time/posix_time/posix_time.hpp> #include <iostream> @@ -116,7 +116,7 @@ public: } void issue_stream_cmd(const stream_cmd_t &cmd){ - _cmd_queue.push_with_wait(boost::make_shared<stream_cmd_t>(cmd)); + _cmd_queue.push_with_wait(std::make_shared<stream_cmd_t>(cmd)); } void stream_on_off(bool enb){ @@ -190,7 +190,7 @@ public: } void recv_cmd_task(void){ //task is looped - boost::shared_ptr<stream_cmd_t> cmd; + std::shared_ptr<stream_cmd_t> cmd; if (_cmd_queue.pop_with_timed_wait(cmd, 0.25)) { recv_cmd_handle_cmd(*cmd); } @@ -213,7 +213,7 @@ private: size_t _nsamps_remaining; stream_cmd_t::stream_mode_t _stream_mode; time_spec_t _time_offset; - bounded_buffer<boost::shared_ptr<stream_cmd_t> > _cmd_queue; + bounded_buffer<std::shared_ptr<stream_cmd_t> > _cmd_queue; bounded_buffer<async_metadata_t> _async_msg_queue; bounded_buffer<rx_metadata_t> _inline_msg_queue; const cb_fcn_type _stream_on_off; diff --git a/host/lib/usrp/usrp1/soft_time_ctrl.hpp b/host/lib/usrp/usrp1/soft_time_ctrl.hpp index 1422a5ced..9143b6af2 100644 --- a/host/lib/usrp/usrp1/soft_time_ctrl.hpp +++ b/host/lib/usrp/usrp1/soft_time_ctrl.hpp @@ -13,7 +13,7 @@ #include <uhd/types/metadata.hpp> #include <uhd/transport/bounded_buffer.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/function.hpp> namespace uhd{ namespace usrp{ @@ -27,7 +27,7 @@ namespace uhd{ namespace usrp{ */ class soft_time_ctrl : uhd::noncopyable{ public: - typedef boost::shared_ptr<soft_time_ctrl> sptr; + typedef std::shared_ptr<soft_time_ctrl> sptr; typedef boost::function<void(bool)> cb_fcn_type; virtual ~soft_time_ctrl(void) = 0; diff --git a/host/lib/usrp/usrp1/usrp1_iface.hpp b/host/lib/usrp/usrp1/usrp1_iface.hpp index 4fb5cd4ee..b01b2d088 100644 --- a/host/lib/usrp/usrp1/usrp1_iface.hpp +++ b/host/lib/usrp/usrp1/usrp1_iface.hpp @@ -11,7 +11,7 @@ #include <uhdlib/usrp/common/fx2_ctrl.hpp> #include <uhd/types/wb_iface.hpp> #include <uhd/types/serial.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/utils/noncopyable.hpp> #define SPI_ENABLE_FPGA 0x01 @@ -35,7 +35,7 @@ class usrp1_iface : public uhd::wb_iface, public uhd::i2c_iface, public uhd::spi_iface, uhd::noncopyable { public: - typedef boost::shared_ptr<usrp1_iface> sptr; + typedef std::shared_ptr<usrp1_iface> sptr; /*! * Make a new usrp1 interface with the control transport. diff --git a/host/lib/usrp/usrp1/usrp1_impl.hpp b/host/lib/usrp/usrp1/usrp1_impl.hpp index 1cf8362e1..9e0a97f47 100644 --- a/host/lib/usrp/usrp1/usrp1_impl.hpp +++ b/host/lib/usrp/usrp1/usrp1_impl.hpp @@ -5,23 +5,23 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include "usrp1_iface.hpp" #include "codec_ctrl.hpp" #include "soft_time_ctrl.hpp" +#include "usrp1_iface.hpp" #include <uhd/device.hpp> #include <uhd/property_tree.hpp> -#include <uhd/utils/pimpl.hpp> +#include <uhd/transport/usb_zero_copy.hpp> #include <uhd/types/dict.hpp> #include <uhd/types/stream_cmd.hpp> +#include <uhd/usrp/dboard_eeprom.hpp> #include <uhd/usrp/dboard_id.hpp> +#include <uhd/usrp/dboard_manager.hpp> #include <uhd/usrp/mboard_eeprom.hpp> #include <uhd/usrp/subdev_spec.hpp> -#include <uhd/usrp/dboard_eeprom.hpp> -#include <uhd/usrp/dboard_manager.hpp> -#include <uhd/transport/usb_zero_copy.hpp> -#include <boost/weak_ptr.hpp> -#include <complex> +#include <uhd/utils/pimpl.hpp> #include <atomic> +#include <complex> +#include <memory> #ifndef INCLUDED_USRP1_IMPL_HPP #define INCLUDED_USRP1_IMPL_HPP @@ -89,8 +89,8 @@ private: double _master_clock_rate; //clock rate shadow //weak pointers to streamers for update purposes - boost::weak_ptr<uhd::rx_streamer> _rx_streamer; - boost::weak_ptr<uhd::tx_streamer> _tx_streamer; + std::weak_ptr<uhd::rx_streamer> _rx_streamer; + std::weak_ptr<uhd::tx_streamer> _tx_streamer; void set_mb_eeprom(const uhd::usrp::mboard_eeprom_t &); void set_db_eeprom(const std::string &, const std::string &, const uhd::usrp::dboard_eeprom_t &); diff --git a/host/lib/usrp/usrp2/clock_ctrl.hpp b/host/lib/usrp/usrp2/clock_ctrl.hpp index 53f0d0aef..b82dd4723 100644 --- a/host/lib/usrp/usrp2/clock_ctrl.hpp +++ b/host/lib/usrp/usrp2/clock_ctrl.hpp @@ -10,12 +10,12 @@ #include "usrp2_iface.hpp" #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <vector> class usrp2_clock_ctrl : uhd::noncopyable{ public: - typedef boost::shared_ptr<usrp2_clock_ctrl> sptr; + typedef std::shared_ptr<usrp2_clock_ctrl> sptr; virtual ~usrp2_clock_ctrl(void) = 0; diff --git a/host/lib/usrp/usrp2/codec_ctrl.hpp b/host/lib/usrp/usrp2/codec_ctrl.hpp index 37c8d6fa3..c769d102a 100644 --- a/host/lib/usrp/usrp2/codec_ctrl.hpp +++ b/host/lib/usrp/usrp2/codec_ctrl.hpp @@ -9,12 +9,12 @@ #define INCLUDED_CODEC_CTRL_HPP #include "usrp2_iface.hpp" -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/utils/noncopyable.hpp> class usrp2_codec_ctrl : uhd::noncopyable{ public: - typedef boost::shared_ptr<usrp2_codec_ctrl> sptr; + typedef std::shared_ptr<usrp2_codec_ctrl> sptr; virtual ~usrp2_codec_ctrl(void) = 0; diff --git a/host/lib/usrp/usrp2/io_impl.cpp b/host/lib/usrp/usrp2/io_impl.cpp index 7042f0391..d965b4e24 100644 --- a/host/lib/usrp/usrp2/io_impl.cpp +++ b/host/lib/usrp/usrp2/io_impl.cpp @@ -24,7 +24,7 @@ #include <boost/bind.hpp> #include <boost/asio.hpp> #include <boost/thread/mutex.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <iostream> #include <chrono> #include <thread> @@ -55,7 +55,7 @@ static const size_t vrt_send_header_offset_words32 = 1; class flow_control_monitor{ public: typedef uint32_t seq_type; - typedef boost::shared_ptr<flow_control_monitor> sptr; + typedef std::shared_ptr<flow_control_monitor> sptr; /*! * Make a new flow control monitor. @@ -256,14 +256,14 @@ void usrp2_impl::update_tick_rate(const double rate){ //update the tick rate on all existing streamers -> thread safe for(const std::string &mb: _mbc.keys()){ for (size_t i = 0; i < _mbc[mb].rx_streamers.size(); i++){ - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>(_mbc[mb].rx_streamers[i].lock()); + std::shared_ptr<sph::recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>(_mbc[mb].rx_streamers[i].lock()); if (my_streamer.get() == NULL) continue; my_streamer->set_tick_rate(rate); } for (size_t i = 0; i < _mbc[mb].tx_streamers.size(); i++){ - boost::shared_ptr<sph::send_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::send_packet_streamer>(_mbc[mb].tx_streamers[i].lock()); + std::shared_ptr<sph::send_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::send_packet_streamer>(_mbc[mb].tx_streamers[i].lock()); if (my_streamer.get() == NULL) continue; my_streamer->set_tick_rate(rate); } @@ -271,8 +271,8 @@ void usrp2_impl::update_tick_rate(const double rate){ } void usrp2_impl::update_rx_samp_rate(const std::string &mb, const size_t dsp, const double rate){ - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>(_mbc[mb].rx_streamers[dsp].lock()); + std::shared_ptr<sph::recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>(_mbc[mb].rx_streamers[dsp].lock()); if (my_streamer.get() == NULL) return; my_streamer->set_samp_rate(rate); @@ -281,8 +281,8 @@ void usrp2_impl::update_rx_samp_rate(const std::string &mb, const size_t dsp, co } void usrp2_impl::update_tx_samp_rate(const std::string &mb, const size_t dsp, const double rate){ - boost::shared_ptr<sph::send_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::send_packet_streamer>(_mbc[mb].tx_streamers[dsp].lock()); + std::shared_ptr<sph::send_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::send_packet_streamer>(_mbc[mb].tx_streamers[dsp].lock()); if (my_streamer.get() == NULL) return; my_streamer->set_samp_rate(rate); @@ -429,7 +429,7 @@ rx_streamer::sptr usrp2_impl::get_rx_stream(const uhd::stream_args_t &args_){ const size_t spp = args.args.cast<size_t>("spp", bpp/bpi); //make the new streamer given the samples per packet - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = boost::make_shared<sph::recv_packet_streamer>(spp); + std::shared_ptr<sph::recv_packet_streamer> my_streamer = std::make_shared<sph::recv_packet_streamer>(spp); //init some streamer stuff my_streamer->resize(args.channels.size()); @@ -498,7 +498,7 @@ tx_streamer::sptr usrp2_impl::get_tx_stream(const uhd::stream_args_t &args_){ const size_t spp = bpp/convert::get_bytes_per_item(args.otw_format); //make the new streamer given the samples per packet - boost::shared_ptr<sph::send_packet_streamer> my_streamer = boost::make_shared<sph::send_packet_streamer>(spp); + std::shared_ptr<sph::send_packet_streamer> my_streamer = std::make_shared<sph::send_packet_streamer>(spp); //init some streamer stuff my_streamer->resize(args.channels.size()); diff --git a/host/lib/usrp/usrp2/usrp2_fifo_ctrl.hpp b/host/lib/usrp/usrp2/usrp2_fifo_ctrl.hpp index 1e670a7f4..cbb243a79 100644 --- a/host/lib/usrp/usrp2/usrp2_fifo_ctrl.hpp +++ b/host/lib/usrp/usrp2/usrp2_fifo_ctrl.hpp @@ -11,7 +11,7 @@ #include <uhd/types/time_spec.hpp> #include <uhd/types/serial.hpp> #include <uhd/transport/zero_copy.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/utility.hpp> #include <uhd/types/wb_iface.hpp> #include <string> @@ -23,7 +23,7 @@ class usrp2_fifo_ctrl : public uhd::timed_wb_iface, public uhd::spi_iface { public: - typedef boost::shared_ptr<usrp2_fifo_ctrl> sptr; + typedef std::shared_ptr<usrp2_fifo_ctrl> sptr; //! Make a new FIFO control object static sptr make(uhd::transport::zero_copy_if::sptr xport); diff --git a/host/lib/usrp/usrp2/usrp2_iface.hpp b/host/lib/usrp/usrp2/usrp2_iface.hpp index 05cdfba54..2752d1a28 100644 --- a/host/lib/usrp/usrp2/usrp2_iface.hpp +++ b/host/lib/usrp/usrp2/usrp2_iface.hpp @@ -11,7 +11,7 @@ #include <uhd/transport/udp_simple.hpp> #include <uhd/types/serial.hpp> #include <uhd/usrp/mboard_eeprom.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/utility.hpp> #include <boost/function.hpp> #include "usrp2_regs.hpp" @@ -26,7 +26,7 @@ class usrp2_iface : public uhd::timed_wb_iface, public uhd::spi_iface, public uhd::i2c_iface { public: - typedef boost::shared_ptr<usrp2_iface> sptr; + typedef std::shared_ptr<usrp2_iface> sptr; /*! * Make a new usrp2 interface with the control transport. * \param ctrl_transport the udp transport object diff --git a/host/lib/usrp/usrp2/usrp2_impl.hpp b/host/lib/usrp/usrp2/usrp2_impl.hpp index 4c86ca7c8..14a3ae8d6 100644 --- a/host/lib/usrp/usrp2/usrp2_impl.hpp +++ b/host/lib/usrp/usrp2/usrp2_impl.hpp @@ -32,8 +32,7 @@ #include <uhd/types/device_addr.hpp> #include <uhd/usrp/dboard_manager.hpp> #include <uhd/usrp/subdev_spec.hpp> -#include <boost/weak_ptr.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/function.hpp> #include <atomic> @@ -84,8 +83,8 @@ private: rx_frontend_core_200::sptr rx_fe; tx_frontend_core_200::sptr tx_fe; std::vector<rx_dsp_core_200::sptr> rx_dsps; - std::vector<boost::weak_ptr<uhd::rx_streamer> > rx_streamers; - std::vector<boost::weak_ptr<uhd::tx_streamer> > tx_streamers; + std::vector<std::weak_ptr<uhd::rx_streamer> > rx_streamers; + std::vector<std::weak_ptr<uhd::tx_streamer> > tx_streamers; tx_dsp_core_200::sptr tx_dsp; time64_core_200::sptr time64; user_settings_core_200::sptr user; diff --git a/host/lib/usrp/x300/x300_adc_ctrl.hpp b/host/lib/usrp/x300/x300_adc_ctrl.hpp index 354b8db49..c69c4c427 100644 --- a/host/lib/usrp/x300/x300_adc_ctrl.hpp +++ b/host/lib/usrp/x300/x300_adc_ctrl.hpp @@ -10,12 +10,12 @@ #include <uhd/types/serial.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> class x300_adc_ctrl : uhd::noncopyable { public: - typedef boost::shared_ptr<x300_adc_ctrl> sptr; + typedef std::shared_ptr<x300_adc_ctrl> sptr; virtual ~x300_adc_ctrl(void) = 0; diff --git a/host/lib/usrp/x300/x300_clock_ctrl.hpp b/host/lib/usrp/x300/x300_clock_ctrl.hpp index 25c2dd33f..af8c3c162 100644 --- a/host/lib/usrp/x300/x300_clock_ctrl.hpp +++ b/host/lib/usrp/x300/x300_clock_ctrl.hpp @@ -10,7 +10,7 @@ #include <uhd/types/serial.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> enum x300_clock_which_t { @@ -28,7 +28,7 @@ enum x300_clock_which_t { class x300_clock_ctrl : uhd::noncopyable { public: - typedef boost::shared_ptr<x300_clock_ctrl> sptr; + typedef std::shared_ptr<x300_clock_ctrl> sptr; virtual ~x300_clock_ctrl(void) = 0; diff --git a/host/lib/usrp/x300/x300_dac_ctrl.hpp b/host/lib/usrp/x300/x300_dac_ctrl.hpp index d73a03d63..9844ffce6 100644 --- a/host/lib/usrp/x300/x300_dac_ctrl.hpp +++ b/host/lib/usrp/x300/x300_dac_ctrl.hpp @@ -10,12 +10,12 @@ #include <uhd/types/serial.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> class x300_dac_ctrl : uhd::noncopyable { public: - typedef boost::shared_ptr<x300_dac_ctrl> sptr; + typedef std::shared_ptr<x300_dac_ctrl> sptr; virtual ~x300_dac_ctrl(void) = 0; diff --git a/host/lib/usrp/x300/x300_mb_eeprom_iface.cpp b/host/lib/usrp/x300/x300_mb_eeprom_iface.cpp index b4dab8291..42d0b32ca 100644 --- a/host/lib/usrp/x300/x300_mb_eeprom_iface.cpp +++ b/host/lib/usrp/x300/x300_mb_eeprom_iface.cpp @@ -27,7 +27,7 @@ #include <uhd/utils/log.hpp> #include <uhd/utils/platform.hpp> #include <boost/thread.hpp> -#include <boost/make_shared.hpp> +#include <memory> using namespace uhd; @@ -158,5 +158,5 @@ x300_mb_eeprom_iface::~x300_mb_eeprom_iface(void) x300_mb_eeprom_iface::sptr x300_mb_eeprom_iface::make( wb_iface::sptr wb, i2c_iface::sptr i2c) { - return boost::make_shared<x300_mb_eeprom_iface_impl>(wb, i2c->eeprom16()); + return std::make_shared<x300_mb_eeprom_iface_impl>(wb, i2c->eeprom16()); } diff --git a/host/lib/usrp/x300/x300_mb_eeprom_iface.hpp b/host/lib/usrp/x300/x300_mb_eeprom_iface.hpp index d323d6359..2d08d5711 100644 --- a/host/lib/usrp/x300/x300_mb_eeprom_iface.hpp +++ b/host/lib/usrp/x300/x300_mb_eeprom_iface.hpp @@ -11,13 +11,13 @@ #include <uhd/config.hpp> #include <uhd/types/serial.hpp> #include <uhd/types/wb_iface.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/utility.hpp> class x300_mb_eeprom_iface : public uhd::i2c_iface { public: - typedef boost::shared_ptr<x300_mb_eeprom_iface> sptr; + typedef std::shared_ptr<x300_mb_eeprom_iface> sptr; virtual ~x300_mb_eeprom_iface(void) = 0; diff --git a/host/lib/usrp/x300/x300_pcie_mgr.cpp b/host/lib/usrp/x300/x300_pcie_mgr.cpp index 6560f2770..8466a5174 100644 --- a/host/lib/usrp/x300/x300_pcie_mgr.cpp +++ b/host/lib/usrp/x300/x300_pcie_mgr.cpp @@ -58,7 +58,7 @@ using namespace uhd::niusrprio; // We need a zpu xport registry to ensure synchronization between the static // finder method and the instances of the x300_impl class. -typedef std::unordered_map<std::string, boost::weak_ptr<uhd::wb_iface>> +typedef std::unordered_map<std::string, std::weak_ptr<uhd::wb_iface>> pcie_zpu_iface_registry_t; UHD_SINGLETON_FCN(pcie_zpu_iface_registry_t, get_pcie_zpu_iface_registry) static std::mutex pcie_zpu_iface_registry_mutex; @@ -249,7 +249,7 @@ wb_iface::sptr pcie_manager::get_ctrl_iface() "Someone else has a ZPU transport to the device open. Internal error!"); } auto zpu_ctrl = x300_make_ctrl_iface_pcie(_rio_fpga_interface->get_kernel_proxy()); - get_pcie_zpu_iface_registry()[_resource] = boost::weak_ptr<wb_iface>(zpu_ctrl); + get_pcie_zpu_iface_registry()[_resource] = std::weak_ptr<wb_iface>(zpu_ctrl); return zpu_ctrl; } diff --git a/host/lib/usrp/x300/x300_radio_control.cpp b/host/lib/usrp/x300/x300_radio_control.cpp index 6cee57827..8e4351d65 100644 --- a/host/lib/usrp/x300/x300_radio_control.cpp +++ b/host/lib/usrp/x300/x300_radio_control.cpp @@ -28,7 +28,7 @@ #include <uhdlib/usrp/cores/spi_core_3000.hpp> #include <uhdlib/usrp/cores/tx_frontend_core_200.hpp> #include <boost/algorithm/string.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <algorithm> #include <chrono> #include <functional> @@ -1492,7 +1492,7 @@ private: // create a new dboard manager RFNOC_LOG_TRACE("Creating DB interface..."); - _db_iface = boost::make_shared<x300_dboard_iface>(db_config); + _db_iface = std::make_shared<x300_dboard_iface>(db_config); RFNOC_LOG_TRACE("Creating DB manager..."); _db_manager = dboard_manager::make(_db_eeproms[RX_EEPROM_ADDR + DB_OFFSET], _db_eeproms[TX_EEPROM_ADDR + DB_OFFSET], @@ -1889,7 +1889,7 @@ private: //! Reference to DB manager usrp::dboard_manager::sptr _db_manager; //! Reference to DB iface - boost::shared_ptr<x300_dboard_iface> _db_iface; + std::shared_ptr<x300_dboard_iface> _db_iface; enum radio_connection_t { PRIMARY, SECONDARY }; radio_connection_t _radio_type; diff --git a/host/lib/usrp_clock/octoclock/octoclock_impl.hpp b/host/lib/usrp_clock/octoclock/octoclock_impl.hpp index d334da3ef..8fcda1999 100644 --- a/host/lib/usrp_clock/octoclock/octoclock_impl.hpp +++ b/host/lib/usrp_clock/octoclock/octoclock_impl.hpp @@ -8,7 +8,7 @@ #ifndef INCLUDED_OCTOCLOCK_IMPL_HPP #define INCLUDED_OCTOCLOCK_IMPL_HPP -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/thread.hpp> #include <uhd/device.hpp> diff --git a/host/lib/utils/ihex.cpp b/host/lib/utils/ihex.cpp index 6bb0ba9d4..fed2b239e 100644 --- a/host/lib/utils/ihex.cpp +++ b/host/lib/utils/ihex.cpp @@ -8,7 +8,7 @@ #include <uhd/exception.hpp> #include <uhdlib/utils/ihex.hpp> #include <boost/format.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <sstream> #include <fstream> @@ -180,7 +180,7 @@ void ihex_reader::read(ihex_reader::record_handle_type record_handler) // We need a functor for the cast, a lambda would be perfect... int _file_writer_callback( - boost::shared_ptr<std::ofstream> output_file, + std::shared_ptr<std::ofstream> output_file, unsigned char *buff, uint16_t len ) { @@ -190,7 +190,7 @@ int _file_writer_callback( void ihex_reader::to_bin_file(const std::string &bin_filename) { - boost::shared_ptr<std::ofstream> output_file(boost::make_shared<std::ofstream>()); + std::shared_ptr<std::ofstream> output_file(std::make_shared<std::ofstream>()); output_file->open(bin_filename.c_str(), std::ios::out | std::ios::binary); if (not output_file->is_open()) { throw uhd::io_error(str(boost::format("Could not open file for writing: %s") % bin_filename)); diff --git a/host/lib/utils/log.cpp b/host/lib/utils/log.cpp index c8d5e07cc..64e3e8e44 100644 --- a/host/lib/utils/log.cpp +++ b/host/lib/utils/log.cpp @@ -14,7 +14,7 @@ #include <uhd/version.hpp> #include <uhdlib/utils/isatty.hpp> #include <boost/date_time/posix_time/posix_time.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <atomic> #include <cctype> #include <fstream> diff --git a/host/python/pyuhd.cpp b/host/python/pyuhd.cpp index b29ca4678..e38dc9224 100644 --- a/host/python/pyuhd.cpp +++ b/host/python/pyuhd.cpp @@ -13,11 +13,6 @@ namespace py = pybind11; -// Allow boost::shared_ptr<T> to be a holder class of an object (PyBind11 -// supports std::shared_ptr and std::unique_ptr out of the box) -#include <boost/shared_ptr.hpp> -PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr<T>); - #include "stream_python.hpp" #include "types/types_python.hpp" diff --git a/host/tests/common/mock_zero_copy.cpp b/host/tests/common/mock_zero_copy.cpp index 0843a0274..8b9e04f64 100644 --- a/host/tests/common/mock_zero_copy.cpp +++ b/host/tests/common/mock_zero_copy.cpp @@ -6,7 +6,7 @@ #include "mock_zero_copy.hpp" -#include <boost/shared_ptr.hpp> +#include <memory> using namespace uhd::transport; diff --git a/host/tests/common/mock_zero_copy.hpp b/host/tests/common/mock_zero_copy.hpp index 515fde498..16a64f5a1 100644 --- a/host/tests/common/mock_zero_copy.hpp +++ b/host/tests/common/mock_zero_copy.hpp @@ -13,9 +13,9 @@ #include <uhd/transport/zero_copy.hpp> #include <uhd/types/endianness.hpp> #include <uhd/utils/byteswap.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <boost/shared_array.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <list> #include <vector> @@ -71,7 +71,7 @@ private: class mock_zero_copy : public uhd::transport::zero_copy_if { public: - typedef boost::shared_ptr<mock_zero_copy> sptr; + typedef std::shared_ptr<mock_zero_copy> sptr; mock_zero_copy(uhd::transport::vrt::if_packet_info_t::link_type_t type, size_t recv_frame_size = DEFAULT_RECV_FRAME_SIZE, diff --git a/host/tests/expert_test.cpp b/host/tests/expert_test.cpp index 36a9ef03b..99e3c1100 100644 --- a/host/tests/expert_test.cpp +++ b/host/tests/expert_test.cpp @@ -9,7 +9,7 @@ #include <uhdlib/experts/expert_container.hpp> #include <uhdlib/experts/expert_factory.hpp> #include <boost/format.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <boost/test/unit_test.hpp> #include <fstream> @@ -112,7 +112,7 @@ private: class worker5_t : public worker_node_t { public: - worker5_t(const node_retriever_t& db, boost::shared_ptr<int> output) + worker5_t(const node_retriever_t& db, std::shared_ptr<int> output) : worker_node_t("Consume_G"), _g(db, "G"), _c(db, "C"), _output(output) { bind_accessor(_g); @@ -128,7 +128,7 @@ private: data_reader_t<int> _g; data_writer_t<int> _c; - boost::shared_ptr<int> _output; + std::shared_ptr<int> _output; }; class worker6_t : public worker_node_t @@ -174,7 +174,7 @@ BOOST_AUTO_TEST_CASE(test_experts) uhd::property_tree::sptr tree = uhd::property_tree::make(); // Output of expert tree - boost::shared_ptr<int> final_output = boost::make_shared<int>(); + std::shared_ptr<int> final_output = std::make_shared<int>(); // Add data nodes to container expert_factory::add_dual_prop_node<int>( diff --git a/host/tests/packet_handler_benchmark.cpp b/host/tests/packet_handler_benchmark.cpp index d0a28bdc2..bf21b0c2b 100644 --- a/host/tests/packet_handler_benchmark.cpp +++ b/host/tests/packet_handler_benchmark.cpp @@ -56,7 +56,7 @@ struct rx_fc_cache_t }; inline bool rx_flow_ctrl( - boost::shared_ptr<rx_fc_cache_t> fc_cache, uhd::transport::managed_buffer::sptr buff) + std::shared_ptr<rx_fc_cache_t> fc_cache, uhd::transport::managed_buffer::sptr buff) { // If the caller supplied a buffer if (buff) { @@ -92,7 +92,7 @@ inline bool rx_flow_ctrl( } inline void handle_rx_flowctrl_ack( - boost::shared_ptr<rx_fc_cache_t> /*fc_cache*/, const uint32_t* /*payload*/) + std::shared_ptr<rx_fc_cache_t> /*fc_cache*/, const uint32_t* /*payload*/) { // For the benchmark, we should never reach this UHD_THROW_INVALID_CODE_PATH(); @@ -119,7 +119,7 @@ struct tx_fc_cache_t pack; }; -inline bool tx_flow_ctrl(boost::shared_ptr<tx_fc_cache_t> fc_cache, +inline bool tx_flow_ctrl(std::shared_ptr<tx_fc_cache_t> fc_cache, uhd::transport::zero_copy_if::sptr /*xport*/, uhd::transport::managed_buffer::sptr buff) { @@ -151,7 +151,7 @@ inline bool tx_flow_ctrl(boost::shared_ptr<tx_fc_cache_t> fc_cache, return false; } -inline void tx_flow_ctrl_ack(boost::shared_ptr<tx_fc_cache_t> fc_cache, +inline void tx_flow_ctrl_ack(std::shared_ptr<tx_fc_cache_t> fc_cache, uhd::transport::zero_copy_if::sptr /*send_xport*/) { if (not fc_cache->fc_received) { @@ -187,7 +187,7 @@ void benchmark_recv_packet_handler(const size_t spp, const std::string& format) xport->set_reuse_recv_memory(true); // Configure xport flow control - boost::shared_ptr<rx_fc_cache_t> fc_cache(new rx_fc_cache_t()); + std::shared_ptr<rx_fc_cache_t> fc_cache(new rx_fc_cache_t()); fc_cache->to_host = uhd::ntohx<uint32_t>; fc_cache->from_host = uhd::htonx<uint32_t>; fc_cache->pack = vrt::chdr::if_hdr_pack_be; @@ -201,7 +201,7 @@ void benchmark_recv_packet_handler(const size_t spp, const std::string& format) }); // Create streamer - auto streamer = boost::make_shared<sph::recv_packet_streamer>(spp); + auto streamer = std::make_shared<sph::recv_packet_streamer>(spp); streamer->set_tick_rate(1.0); streamer->set_samp_rate(1.0); @@ -260,7 +260,7 @@ void benchmark_send_packet_handler( xport->set_reuse_send_memory(true); // Configure flow control - boost::shared_ptr<tx_fc_cache_t> fc_cache(new tx_fc_cache_t()); + std::shared_ptr<tx_fc_cache_t> fc_cache(new tx_fc_cache_t()); fc_cache->to_host = uhd::ntohx<uint32_t>; fc_cache->from_host = uhd::htonx<uint32_t>; fc_cache->pack = vrt::chdr::if_hdr_pack_be; @@ -274,7 +274,7 @@ void benchmark_send_packet_handler( 0); // Create streamer - auto streamer = boost::make_shared<sph::send_packet_streamer>(spp); + auto streamer = std::make_shared<sph::send_packet_streamer>(spp); streamer->set_vrt_packer(&vrt::chdr::if_hdr_pack_be); // Configure converter diff --git a/host/tests/rx_streamer_test.cpp b/host/tests/rx_streamer_test.cpp index cd4daf569..1b1311908 100644 --- a/host/tests/rx_streamer_test.cpp +++ b/host/tests/rx_streamer_test.cpp @@ -6,7 +6,7 @@ #include "../common/mock_link.hpp" #include <uhdlib/transport/rx_streamer_impl.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <boost/test/unit_test.hpp> #include <iostream> @@ -148,13 +148,13 @@ static std::vector<mock_recv_link::sptr> make_links(const size_t num) return links; } -static boost::shared_ptr<mock_rx_streamer> make_rx_streamer( +static std::shared_ptr<mock_rx_streamer> make_rx_streamer( std::vector<mock_recv_link::sptr> recv_links, const std::string& host_format, const std::string& otw_format = "sc16") { const uhd::stream_args_t stream_args(host_format, otw_format); - auto streamer = boost::make_shared<mock_rx_streamer>(recv_links.size(), stream_args); + auto streamer = std::make_shared<mock_rx_streamer>(recv_links.size(), stream_args); streamer->set_tick_rate(TICK_RATE); streamer->set_samp_rate(SAMP_RATE); diff --git a/host/tests/sph_recv_test.cpp b/host/tests/sph_recv_test.cpp index 3c185d21a..5685028d6 100644 --- a/host/tests/sph_recv_test.cpp +++ b/host/tests/sph_recv_test.cpp @@ -336,7 +336,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_normal) std::vector<mock_zero_copy::sptr> xports; for (size_t i = 0; i < NCHANNELS; i++) { xports.push_back( - boost::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); + std::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); } // generate a bunch of packets @@ -432,7 +432,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_sequence_error) std::vector<mock_zero_copy::sptr> xports; for (size_t i = 0; i < NCHANNELS; i++) { xports.push_back( - boost::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); + std::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); } // generate a bunch of packets @@ -540,7 +540,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_time_error) std::vector<mock_zero_copy::sptr> xports; for (size_t i = 0; i < NCHANNELS; i++) { xports.push_back( - boost::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); + std::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); } // generate a bunch of packets @@ -642,7 +642,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_exception) std::vector<mock_zero_copy::sptr> xports; for (size_t i = 0; i < NCHANNELS; i++) { xports.push_back( - boost::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); + std::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); } // generate a bunch of packets @@ -720,7 +720,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_fragment) std::vector<mock_zero_copy::sptr> xports; for (size_t i = 0; i < NCHANNELS; i++) { xports.push_back( - boost::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); + std::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); } // generate a bunch of packets diff --git a/host/tests/streamer_benchmark.cpp b/host/tests/streamer_benchmark.cpp index 46ba6add0..02aa102a0 100644 --- a/host/tests/streamer_benchmark.cpp +++ b/host/tests/streamer_benchmark.cpp @@ -12,7 +12,7 @@ #include <uhdlib/transport/inline_io_service.hpp> #include <uhdlib/transport/rx_streamer_impl.hpp> #include <uhdlib/transport/tx_streamer_impl.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <boost/program_options.hpp> #include <chrono> #include <iostream> @@ -219,11 +219,11 @@ using tx_streamer_mock_link = mock_tx_streamer<chdr_tx_data_xport>; /*! * Helper functions */ -static boost::shared_ptr<rx_streamer_mock_xport> make_rx_streamer_mock_xport( +static std::shared_ptr<rx_streamer_mock_xport> make_rx_streamer_mock_xport( const size_t spp, const std::string& format) { const uhd::stream_args_t stream_args(format, "sc16"); - auto streamer = boost::make_shared<rx_streamer_mock_xport>(1, stream_args); + auto streamer = std::make_shared<rx_streamer_mock_xport>(1, stream_args); streamer->set_tick_rate(TICK_RATE); streamer->set_samp_rate(SAMP_RATE); streamer->set_scale_factor(0, SCALE_FACTOR); @@ -238,11 +238,11 @@ static boost::shared_ptr<rx_streamer_mock_xport> make_rx_streamer_mock_xport( return streamer; } -static boost::shared_ptr<tx_streamer_mock_xport> make_tx_streamer_mock_xport( +static std::shared_ptr<tx_streamer_mock_xport> make_tx_streamer_mock_xport( const size_t spp, const std::string& format) { const uhd::stream_args_t stream_args(format, "sc16"); - auto streamer = boost::make_shared<tx_streamer_mock_xport>(1, stream_args); + auto streamer = std::make_shared<tx_streamer_mock_xport>(1, stream_args); streamer->set_tick_rate(TICK_RATE); streamer->set_samp_rate(SAMP_RATE); streamer->set_scale_factor(0, SCALE_FACTOR); @@ -257,11 +257,11 @@ static boost::shared_ptr<tx_streamer_mock_xport> make_tx_streamer_mock_xport( return streamer; } -static boost::shared_ptr<rx_streamer_mock_link> make_rx_streamer_mock_link( +static std::shared_ptr<rx_streamer_mock_link> make_rx_streamer_mock_link( const size_t spp, const std::string& format) { const uhd::stream_args_t stream_args(format, "sc16"); - auto streamer = boost::make_shared<rx_streamer_mock_link>(1, stream_args); + auto streamer = std::make_shared<rx_streamer_mock_link>(1, stream_args); streamer->set_tick_rate(TICK_RATE); streamer->set_samp_rate(SAMP_RATE); streamer->set_scale_factor(0, SCALE_FACTOR); @@ -307,11 +307,11 @@ static boost::shared_ptr<rx_streamer_mock_link> make_rx_streamer_mock_link( return streamer; } -static boost::shared_ptr<tx_streamer_mock_link> make_tx_streamer_mock_link( +static std::shared_ptr<tx_streamer_mock_link> make_tx_streamer_mock_link( const size_t spp, const std::string& format) { const uhd::stream_args_t stream_args(format, "sc16"); - auto streamer = boost::make_shared<tx_streamer_mock_link>(1, stream_args); + auto streamer = std::make_shared<tx_streamer_mock_link>(1, stream_args); streamer->set_tick_rate(TICK_RATE); streamer->set_samp_rate(SAMP_RATE); streamer->set_scale_factor(0, SCALE_FACTOR); diff --git a/host/tests/tx_streamer_test.cpp b/host/tests/tx_streamer_test.cpp index 686c1b761..09c8357df 100644 --- a/host/tests/tx_streamer_test.cpp +++ b/host/tests/tx_streamer_test.cpp @@ -6,7 +6,7 @@ #include "../common/mock_link.hpp" #include <uhdlib/transport/tx_streamer_impl.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <boost/test/unit_test.hpp> #include <iostream> @@ -121,11 +121,11 @@ static std::vector<mock_send_link::sptr> make_links(const size_t num) return links; } -static boost::shared_ptr<mock_tx_streamer> make_tx_streamer( +static std::shared_ptr<mock_tx_streamer> make_tx_streamer( std::vector<mock_send_link::sptr> send_links, const std::string& format) { const uhd::stream_args_t stream_args(format, "sc16"); - auto streamer = boost::make_shared<mock_tx_streamer>(send_links.size(), stream_args); + auto streamer = std::make_shared<mock_tx_streamer>(send_links.size(), stream_args); streamer->set_tick_rate(TICK_RATE); streamer->set_samp_rate(SAMP_RATE); @@ -379,7 +379,7 @@ BOOST_AUTO_TEST_CASE(test_spp) auto send_links = make_links(1); uhd::stream_args_t stream_args("fc64", "sc16"); stream_args.args["spp"] = std::to_string(10); - auto streamer = boost::make_shared<mock_tx_streamer>(send_links.size(), stream_args); + auto streamer = std::make_shared<mock_tx_streamer>(send_links.size(), stream_args); mock_tx_data_xport::uptr xport(std::make_unique<mock_tx_data_xport>(send_links[0])); streamer->connect_channel(0, std::move(xport)); BOOST_CHECK_EQUAL(streamer->get_max_num_samps(), 10); @@ -390,7 +390,7 @@ BOOST_AUTO_TEST_CASE(test_spp) auto send_links = make_links(1); uhd::stream_args_t stream_args("fc64", "sc16"); stream_args.args["spp"] = std::to_string(10000); - auto streamer = boost::make_shared<mock_tx_streamer>(send_links.size(), stream_args); + auto streamer = std::make_shared<mock_tx_streamer>(send_links.size(), stream_args); mock_tx_data_xport::uptr xport(std::make_unique<mock_tx_data_xport>(send_links[0])); const size_t max_pyld = xport->get_max_payload_size(); streamer->connect_channel(0, std::move(xport)); diff --git a/host/utils/latency/responder.cpp b/host/utils/latency/responder.cpp index fd47ad085..9b27fdcb8 100644 --- a/host/utils/latency/responder.cpp +++ b/host/utils/latency/responder.cpp @@ -117,6 +117,6 @@ int UHD_SAFE_MAIN(int argc, char* argv[]) } // create a new instance of Responder and run it! - boost::shared_ptr<Responder> my_responder(new Responder(prog)); + std::shared_ptr<Responder> my_responder(new Responder(prog)); return my_responder->run(); } |