uhd: Replace usage of boost smart pointers with C++11 counterparts

This removes the following Boost constructs:
- boost::shared_ptr, boost::weak_ptr
- boost::enable_shared_from_this
- boost::static_pointer_cast, boost::dynamic_pointer_cast

The appropriate includes were also removed. All C++11 versions of these
require #include <memory>.
Note that the stdlib and Boost versions have the exact same syntax, they
only differ in the namespace (boost vs. std). The modifications were all
done using sed, with the exception of boost::scoped_ptr, which was
replaced by std::unique_ptr.

References to boost::smart_ptr were also removed.

boost::intrusive_ptr is not removed in this commit, since it does not
have a 1:1 mapping to a C++11 construct.

12 files changed, 60 insertions, 61 deletions

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;