uhd: Added an update() method for dicts

Very similar to Python's dict.update().

4 files changed, 64 insertions, 1 deletions

diff --git a/host/include/uhd/types/dict.hpp b/host/include/uhd/types/dict.hpp
index 97fa8f09c..51e3e1814 100644
--- a/host/include/uhd/types/dict.hpp
+++ b/host/include/uhd/types/dict.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2010-2011 Ettus Research LLC
+// Copyright 2010-2011,2015 Ettus Research LLC
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -117,6 +117,23 @@ namespace uhd{
          */
         Val pop(const Key &key);
 
+        /*! Update this dictionary with values from another.
+         *
+         * Basically, this copies all the key/value pairs from \p new_dict
+         * into this dict. When the key is already present in the current
+         * dict, it either overwrites the current value (if \p fail_on_conflict
+         * is false) or it throws (if \p fail_on_conflict is true *and* the
+         * values differ).
+         *
+         * With the exception of \p fail_on_conflict, this behaves analogously
+         * to Python's dict.update() method.
+         *
+         * \param new_args The arguments to copy.
+         * \param fail_on_conflict If true, throws.
+         * \throws uhd::value_error
+         */
+        void update(const dict<Key, Val> &new_dict, bool fail_on_conflict=true);
+
     private:
         typedef std::pair<Key, Val> pair_t;
         std::list<pair_t> _map; //private container
diff --git a/host/include/uhd/types/dict.ipp b/host/include/uhd/types/dict.ipp
index 5e9cf97ad..5fd4b536e 100644
--- a/host/include/uhd/types/dict.ipp
+++ b/host/include/uhd/types/dict.ipp
@@ -135,6 +135,20 @@ namespace uhd{
         throw key_not_found<Key, Val>(key);
     }
 
+    template <typename Key, typename Val>
+    void dict<Key, Val>::update(const dict<Key, Val> &new_dict, bool fail_on_conflict)
+    {
+        BOOST_FOREACH(const Key &key, new_dict.keys()) {
+            if (fail_on_conflict and has_key(key) and get(key) != new_dict[key]) {
+                throw uhd::value_error(str(
+                    boost::format("Option merge conflict: %s:%s != %s:%s")
+                    % key % get(key) % key % new_dict[key]
+                ));
+            }
+            set(key, new_dict[key]);
+        }
+    }
+
 } //namespace uhd
 
 #endif /* INCLUDED_UHD_TYPES_DICT_IPP */
diff --git a/host/tests/addr_test.cpp b/host/tests/addr_test.cpp
index cea2f224c..61bb6d049 100644
--- a/host/tests/addr_test.cpp
+++ b/host/tests/addr_test.cpp
@@ -66,6 +66,13 @@ BOOST_AUTO_TEST_CASE(test_device_addr){
         old_dev_addr_vals.begin(), old_dev_addr_vals.end(),
         new_dev_addr_vals.begin(), new_dev_addr_vals.end()
     );
+
+    uhd::device_addr_t dev_addr_lhs1("key1=val1,key2=val2");
+    dev_addr_lhs1.update(uhd::device_addr_t("key2=val2x,key3=val3"), false);
+    BOOST_CHECK_EQUAL(dev_addr_lhs1["key1"], "val1");
+    BOOST_CHECK_EQUAL(dev_addr_lhs1["key2"], "val2x");
+    BOOST_CHECK_EQUAL(dev_addr_lhs1["key3"], "val3");
+    std::cout << "Merged: " << dev_addr_lhs1.to_string() << std::endl;
 }
 
 BOOST_AUTO_TEST_CASE(test_dboard_id){
diff --git a/host/tests/dict_test.cpp b/host/tests/dict_test.cpp
index 7b388d090..333aadbba 100644
--- a/host/tests/dict_test.cpp
+++ b/host/tests/dict_test.cpp
@@ -70,3 +70,28 @@ BOOST_AUTO_TEST_CASE(test_dict_pop){
     BOOST_CHECK(d.keys()[0] == -1);
     BOOST_CHECK(d.keys()[1] == 1);
 }
+
+BOOST_AUTO_TEST_CASE(test_dict_update)
+{
+    uhd::dict<std::string, std::string> d1 = boost::assign::map_list_of
+        ("key1", "val1")
+        ("key2", "val2")
+    ;
+    uhd::dict<std::string, std::string> d2 = boost::assign::map_list_of
+        ("key2", "val2x")
+        ("key3", "val3")
+    ;
+
+    d1.update(d2, false /* don't throw cause of conflict */);
+    BOOST_CHECK_EQUAL(d1["key1"], "val1");
+    BOOST_CHECK_EQUAL(d1["key2"], "val2x");
+    BOOST_CHECK_EQUAL(d1["key3"], "val3");
+
+    uhd::dict<std::string, std::string> d3 = boost::assign::map_list_of
+        ("key1", "val1")
+        ("key2", "val2")
+    ;
+    BOOST_CHECK_THROW(d3.update(d2), uhd::value_error);
+}
+
+