Switch SvcParam to std::move semantics

diff --git a/pdns/dnsparser.cc b/pdns/dnsparser.cc
index 245f3c8e384e7a3b6e7a4238dcef429dcba66a04..193cb1f3d298b18e89fd870dae181ee7511d24a9 100644 (file)
--- a/pdns/dnsparser.cc
+++ b/pdns/dnsparser.cc
@@ -584,7 +584,7 @@ void PacketReader::xfrSvcParamKeyVals(set<SvcParam> &kvs) {
         xfr16BitInt(keyval);
         paramKeys.insert(static_cast<SvcParam::SvcParamKey>(keyval));
       }
-      kvs.insert(SvcParam(key, paramKeys));
+      kvs.insert(SvcParam(key, std::move(paramKeys)));
       break;
     }
     case SvcParam::alpn: {
@@ -600,7 +600,7 @@ void PacketReader::xfrSvcParamKeyVals(set<SvcParam> &kvs) {
         xfrBlob(alpn, alpnLen);
         alpns.push_back(alpn);
       }
-      kvs.insert(SvcParam(key, alpns));
+      kvs.insert(SvcParam(key, std::move(alpns)));
       break;
     }
     case SvcParam::no_default_alpn: {
@@ -633,7 +633,7 @@ void PacketReader::xfrSvcParamKeyVals(set<SvcParam> &kvs) {
         xfrCAWithoutPort(key, addr);
         addresses.push_back(addr);
       }
-      kvs.insert(SvcParam(key, addresses));
+      kvs.insert(SvcParam(key, std::move(addresses)));
       break;
     }
     case SvcParam::echconfig: {

diff --git a/pdns/rcpgenerator.cc b/pdns/rcpgenerator.cc
index eca64b68a4a2811fade537620df47d0a1012c061..c54673ad0ef2f0bf1f25aa4f6f499a6a17cbfd69 100644 (file)
--- a/pdns/rcpgenerator.cc
+++ b/pdns/rcpgenerator.cc
@@ -350,7 +350,7 @@ void RecordTextReader::xfrSvcParamKeyVals(set<SvcParam>& val)
         }
       } while (d_pos != d_end && d_string.at(d_pos) != ' ');
       try {
-        val.insert(SvcParam(key, hints));
+        val.insert(SvcParam(key, std::move(hints)));
       }
       catch (const std::invalid_argument& e) {
         throw RecordTextException(e.what());
@@ -362,7 +362,7 @@ void RecordTextReader::xfrSvcParamKeyVals(set<SvcParam>& val)
       xfrUnquotedText(value, false);
       vector<string> parts;
       stringtok(parts, value, ",");
-      val.insert(SvcParam(key, parts));
+      val.insert(SvcParam(key, std::move(parts)));
       break;
     }
     case SvcParam::mandatory: {
@@ -371,7 +371,7 @@ void RecordTextReader::xfrSvcParamKeyVals(set<SvcParam>& val)
       vector<string> parts;
       stringtok(parts, value, ",");
       set<string> values(parts.begin(), parts.end());
-      val.insert(SvcParam(key, values));
+      val.insert(SvcParam(key, std::move(values)));
       break;
     }
     case SvcParam::port: {

diff --git a/pdns/svc-records.cc b/pdns/svc-records.cc
index c54241c1a457723243daaf12c524842daf1abe55..332209aeb98f0567cb80f159cf291925eeeef845 100644 (file)
--- a/pdns/svc-records.cc
+++ b/pdns/svc-records.cc
@@ -79,7 +79,7 @@ SvcParam::SvcParam(const SvcParamKey &key, const std::string &value) {
   d_value = std::move(value);
 }
 
-SvcParam::SvcParam(const SvcParamKey &key, const std::vector<std::string> & value) {
+SvcParam::SvcParam(const SvcParamKey &key, std::vector<std::string> &&value) {
   d_key = key;
   if (d_key != SvcParamKey::alpn) {
     throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a string-set value");
@@ -89,7 +89,7 @@ SvcParam::SvcParam(const SvcParamKey &key, const std::vector<std::string> & valu
   }
 }
 
-SvcParam::SvcParam(const SvcParamKey &key, const std::set<std::string> &value) {
+SvcParam::SvcParam(const SvcParamKey &key, std::set<std::string> &&value) {
   d_key = key;
   if (d_key != SvcParamKey::mandatory) {
     throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a string-set value");
@@ -101,7 +101,7 @@ SvcParam::SvcParam(const SvcParamKey &key, const std::set<std::string> &value) {
   }
 }
 
-SvcParam::SvcParam(const SvcParamKey &key, const std::set<SvcParam::SvcParamKey> &value) {
+SvcParam::SvcParam(const SvcParamKey &key, std::set<SvcParam::SvcParamKey> &&value) {
   d_key = key;
   if (d_key != SvcParamKey::mandatory) {
     throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a string-set value");
@@ -109,7 +109,7 @@ SvcParam::SvcParam(const SvcParamKey &key, const std::set<SvcParam::SvcParamKey>
   d_mandatory = std::move(value);
 }
 
-SvcParam::SvcParam(const SvcParamKey &key, const std::vector<ComboAddress> &value) {
+SvcParam::SvcParam(const SvcParamKey &key, std::vector<ComboAddress> &&value) {
   d_key = key;
   if (d_key != SvcParamKey::ipv6hint && d_key != SvcParamKey::ipv4hint) {
     throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with an IP address value");

diff --git a/pdns/svc-records.hh b/pdns/svc-records.hh
index 2552ff4fb3b4a738f709264f17a8188d7e29cd8c..69f8cba43dd0803eaffec882b6f30d5a9b5ca987 100644 (file)
--- a/pdns/svc-records.hh
+++ b/pdns/svc-records.hh
@@ -51,16 +51,16 @@ class SvcParam {
   SvcParam(const SvcParamKey &key, const std::string &value);
 
   //! To create a multi-value SvcParam (like mandatory)
-  SvcParam(const SvcParamKey &key, const std::set<std::string> &value);
+  SvcParam(const SvcParamKey &key, std::set<std::string> &&value);
 
   //! To create a multi-value SvcParam (like alpn)
-  SvcParam(const SvcParamKey &key, const std::vector<std::string> &value);
+  SvcParam(const SvcParamKey &key, std::vector<std::string> &&value);
 
   //! To create a multi-value SvcParam with key values (like mandatory)
-  SvcParam(const SvcParamKey &key, const std::set<SvcParamKey> &value);
+  SvcParam(const SvcParamKey &key, std::set<SvcParamKey> &&value);
 
   //! To create and ipv{4,6}hists SvcParam
-  SvcParam(const SvcParamKey &key, const std::vector<ComboAddress> &value);
+  SvcParam(const SvcParamKey &key, std::vector<ComboAddress> &&value);
 
   //! To create a port SvcParam
   SvcParam(const SvcParamKey &key, const uint16_t value);

diff --git a/pdns/test-dnswriter_cc.cc b/pdns/test-dnswriter_cc.cc
index 4a73e66b993c2a6d86c236d28af0cadcb268ffe1..1c6588287ac67a11558a32d2dfcac3f94f4a8788 100644 (file)
--- a/pdns/test-dnswriter_cc.cc
+++ b/pdns/test-dnswriter_cc.cc
@@ -85,7 +85,7 @@ BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_mandatory) {
   pwR.getHeader()->qr = 1;
 
   set<string> keys({"alpn", "ipv6hint"});
-  set<SvcParam> params({SvcParam(SvcParam::mandatory, keys)});
+  set<SvcParam> params({SvcParam(SvcParam::mandatory, std::move(keys))});
 
   pwR.startRecord(name, QType::SVCB);
   pwR.commit();
@@ -108,7 +108,7 @@ BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_alpn) {
   pwR.getHeader()->qr = 1;
 
   vector<string> alpns({"h2", "h2c", "h3"});
-  set<SvcParam> params({SvcParam(SvcParam::alpn, alpns)});
+  set<SvcParam> params({SvcParam(SvcParam::alpn, std::move(alpns))});
 
   pwR.startRecord(name, QType::SVCB);
   pwR.commit();
@@ -179,7 +179,7 @@ BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_ipv4hint) {
   pwR.getHeader()->qr = 1;
 
   vector<ComboAddress> addrs({ComboAddress("192.0.2.1"), ComboAddress("192.0.2.2")});
-  set<SvcParam> params({SvcParam(SvcParam::ipv4hint, addrs)});
+  set<SvcParam> params({SvcParam(SvcParam::ipv4hint, std::move(addrs))});
 
   pwR.startRecord(name, QType::SVCB);
   pwR.commit();
@@ -227,7 +227,7 @@ BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_ipv6hint) {
   pwR.getHeader()->qr = 1;
 
   vector<ComboAddress> addrs({ComboAddress("2001:db8::1"), ComboAddress("2001:db8::2")});
-  set<SvcParam> params({SvcParam(SvcParam::ipv6hint, addrs)});
+  set<SvcParam> params({SvcParam(SvcParam::ipv6hint, std::move(addrs))});
 
   pwR.startRecord(name, QType::SVCB);
   pwR.commit();
@@ -277,7 +277,7 @@ BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_multiple) {
 
   vector<ComboAddress> addrs({ComboAddress("2001:db8::1"), ComboAddress("2001:db8::2")});
   vector<string> alpns({"h2", "h2c", "h3"});
-  set<SvcParam> params({SvcParam(SvcParam::alpn, alpns), SvcParam(SvcParam::ipv6hint, addrs), SvcParam(SvcParam::port, 53)});
+  set<SvcParam> params({SvcParam(SvcParam::alpn, std::move(alpns)), SvcParam(SvcParam::ipv6hint, std::move(addrs)), SvcParam(SvcParam::port, 53)});
 
   pwR.startRecord(name, QType::SVCB);
   pwR.commit();

diff --git a/pdns/test-svc_records_cc.cc b/pdns/test-svc_records_cc.cc
index 3e0989ad46bd31aa41aec6628d20765603d01021..9571b63b983a753465864e253153fd97607a6a90 100644 (file)
--- a/pdns/test-svc_records_cc.cc
+++ b/pdns/test-svc_records_cc.cc
@@ -109,17 +109,17 @@ BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_value) {
 BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_set_string_value) {
     set<string> val({"foo", "bar", "baz"});
 
-    BOOST_CHECK_THROW(SvcParam(SvcParam::alpn, val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::port, val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::echconfig, val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, val), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::alpn, std::move(val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, std::move(val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::port, std::move(val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, std::move(val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::echconfig, std::move(val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, std::move(val)), std::invalid_argument);
 
     set<string> mandatoryVal = {"alpn", "key666"};
     set<SvcParam::SvcParamKey> mandatoryExpected = {SvcParam::alpn, (SvcParam::SvcParamKey)666};
     SvcParam param;
-    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::keyFromString("mandatory"), mandatoryVal));
+    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::keyFromString("mandatory"), std::move(mandatoryVal)));
 
     auto retval = param.getMandatory();
     BOOST_CHECK(retval == mandatoryExpected);
@@ -132,19 +132,20 @@ BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_set_string_value) {
 
 BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_vector_string_value) {
     auto val = vector<string>({"h3, h2"});
+    auto checkVal = val;
 
-    BOOST_CHECK_THROW(SvcParam(SvcParam::mandatory, val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::port, val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::echconfig, val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, val), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::mandatory, std::move(val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, std::move(val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::port, std::move(val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, std::move(val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::echconfig, std::move(val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, std::move(val)), std::invalid_argument);
 
     SvcParam param;
-    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::keyFromString("alpn"), val));
+    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::keyFromString("alpn"), std::move(val)));
     auto alpns = param.getALPN();
 
-    BOOST_CHECK_EQUAL_COLLECTIONS(alpns.begin(), alpns.end(), val.begin(), val.end());
+    BOOST_CHECK_EQUAL_COLLECTIONS(alpns.begin(), alpns.end(), checkVal.begin(), checkVal.end());
     BOOST_CHECK_THROW(param.getMandatory(), std::invalid_argument);
     BOOST_CHECK_THROW(param.getEchConfig(), std::invalid_argument);
     BOOST_CHECK_THROW(param.getIPHints(), std::invalid_argument);
@@ -160,34 +161,36 @@ BOOST_AUTO_TEST_CASE(test_SvcParam_ctor_set_comboaddress_value) {
 
     vector<ComboAddress> mixedVal({ca1, ca3});
     vector<ComboAddress> v4Val({ca1, ca2});
+    auto v4CheckVal = v4Val;
     vector<ComboAddress> v6Val({ca3, ca4});
+    auto v6CheckVal = v6Val;
 
-    BOOST_CHECK_THROW(SvcParam(SvcParam::mandatory, v4Val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::alpn, v4Val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, v4Val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::port, v4Val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::echconfig, v4Val), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::mandatory, std::move(v4Val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::alpn, std::move(v4Val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::no_default_alpn, std::move(v4Val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::port, std::move(v4Val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::echconfig, std::move(v4Val)), std::invalid_argument);
 
-    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, v4Val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, v6Val), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, mixedVal), std::invalid_argument);
-    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, mixedVal), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, std::move(v4Val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, std::move(v6Val)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv6hint, std::move(mixedVal)), std::invalid_argument);
+    BOOST_CHECK_THROW(SvcParam(SvcParam::ipv4hint, std::move(mixedVal)), std::invalid_argument);
 
     SvcParam param;
-    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::ipv4hint, v4Val));
+    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::ipv4hint, std::move(v4Val)));
 
     auto retval = param.getIPHints();
-    BOOST_CHECK(retval == v4Val);
+    BOOST_CHECK(retval == v4CheckVal);
     BOOST_CHECK_THROW(param.getMandatory(), std::invalid_argument);
     BOOST_CHECK_THROW(param.getALPN(), std::invalid_argument);
     BOOST_CHECK_THROW(param.getEchConfig(), std::invalid_argument);
     BOOST_CHECK_THROW(param.getPort(), std::invalid_argument);
     BOOST_CHECK_THROW(param.getValue(), std::invalid_argument);
 
-    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::ipv6hint, v6Val));
+    BOOST_CHECK_NO_THROW(param = SvcParam(SvcParam::ipv6hint, std::move(v6Val)));
     retval.clear();
     retval = param.getIPHints();
-    BOOST_CHECK(retval == v6Val);
+    BOOST_CHECK(retval == v6CheckVal);
     BOOST_CHECK_THROW(param.getMandatory(), std::invalid_argument);
     BOOST_CHECK_THROW(param.getALPN(), std::invalid_argument);
     BOOST_CHECK_THROW(param.getEchConfig(), std::invalid_argument);