uhd: Replace Boost mutexes and locks with standard options

This is a very mechanical task that could almost have been done with
sed. Boost versions of mutexes and locks were removed, and replaced with
std:: versions. The replacement tables are as follows:

== Mutexes ==
- boost::mutex -> std::mutex
- boost::recursive_mutex -> std::recursive_mutex

Mutexes behave identically between Boost and std:: and have the same
API.

== Locks ==
C++11 has only two types of lock that we use/need in UHD:
- std::lock_guard: Identical to boost::lock_guard
- std::unique_lock: Identical to boost::unique_lock

Boost also has boost::mutex::scoped_lock, which is a typedef for
boost::unique_lock<>. However, we often have used scoped_lock where we
meant to use lock_guard<>. The name is a bit misleading, "scoped lock"
sounding a bit like an RAII mechanism. Therefore, some previous
boost::mutex::scoped_lock are now std::lock_guard<>.

std::unique_lock is required when doing more than RAII locking (i.e.,
unlocking, relocking, usage with condition variables, etc.).

== Condition Variables ==
Condition variables were out of the scope of this lock/mutex change, but
in UHD, we inconsistently use boost::condition vs.
boost::condition_variable. The former is a templated version of the
latter, and thus works fine with std::mutex'es. Therefore, some
boost::condition_variable where changed to boost::condition.

All locks and mutexes use `#include <mutex>`. The corresponding Boost
includes were removed. In some cases, this exposed issues with implicit
Boost includes elsewhere. The missing explicit includes were added.

1 files changed, 8 insertions, 9 deletions

diff --git a/host/lib/device.cpp b/host/lib/device.cpp
index 62277134b..0d64b4f4c 100644
--- a/host/lib/device.cpp
+++ b/host/lib/device.cpp
@@ -12,16 +12,15 @@
 #include <uhd/utils/log.hpp>
 #include <uhd/utils/static.hpp>
 #include <uhdlib/utils/prefs.hpp>
-#include <boost/format.hpp>
 #include <boost/functional/hash.hpp>
-#include <boost/thread/mutex.hpp>
 #include <future>
 #include <memory>
+#include <mutex>
 #include <tuple>
 
 using namespace uhd;
 
-static boost::mutex _device_mutex;
+static std::mutex _device_mutex;
 
 /***********************************************************************
  * Helper Functions
@@ -82,7 +81,7 @@ device::~device(void)
  **********************************************************************/
 device_addrs_t device::find(const device_addr_t& hint, device_filter_t filter)
 {
-    boost::mutex::scoped_lock lock(_device_mutex);
+    std::lock_guard<std::mutex> lock(_device_mutex);
 
     device_addrs_t device_addrs;
     std::vector<std::future<device_addrs_t>> find_tasks;
@@ -110,7 +109,7 @@ device_addrs_t device::find(const device_addr_t& hint, device_filter_t filter)
  **********************************************************************/
 device::sptr device::make(const device_addr_t& hint, device_filter_t filter, size_t which)
 {
-    boost::mutex::scoped_lock lock(_device_mutex);
+    std::lock_guard<std::mutex> lock(_device_mutex);
 
     typedef std::tuple<device_addr_t, make_t> dev_addr_make_t;
     std::vector<dev_addr_make_t> dev_addr_makers;
@@ -132,13 +131,13 @@ device::sptr device::make(const device_addr_t& hint, device_filter_t filter, siz
     // check that we found any devices
     if (dev_addr_makers.empty()) {
         throw uhd::key_error(
-            str(boost::format("No devices found for ----->\n%s") % hint.to_pp_string()));
+            std::string("No devices found for ----->\n") + hint.to_pp_string());
     }
 
     // check that the which index is valid
     if (dev_addr_makers.size() <= which) {
-        throw uhd::index_error(str(boost::format("No device at index %d for ----->\n%s")
-                                   % which % hint.to_pp_string()));
+        throw uhd::index_error("No device at index " + std::to_string(which)
+                               + " for ----->\n" + hint.to_pp_string());
     }
 
     // create a unique hash for the device address
@@ -146,7 +145,7 @@ device::sptr device::make(const device_addr_t& hint, device_filter_t filter, siz
     make_t maker;
     std::tie(dev_addr, maker) = dev_addr_makers.at(which);
     size_t dev_hash           = hash_device_addr(dev_addr);
-    UHD_LOGGER_TRACE("UHD") << boost::format("Device hash: %u") % dev_hash;
+    UHD_LOGGER_TRACE("UHD") << "Device hash: " << dev_hash;
 
     // copy keys that were in hint but not in dev_addr
     // this way, we can pass additional transport arguments