From: Pieter Lexis <pieter.lexis@powerdns.com>
Date: Thu, 24 Sep 2020 14:08:05 +0000 (+0200)
Subject: Switch SvcParam to std::move semantics
X-Git-Tag: auth-4.4.0-alpha1~2^2~1
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=96fdac2aa17424dca0e0b6b4255064708058067a;p=thirdparty%2Fpdns.git

Switch SvcParam to std::move semantics
---

diff --git a/pdns/dnsparser.cc b/pdns/dnsparser.cc
index 245f3c8e38..193cb1f3d2 100644
--- 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 eca64b68a4..c54673ad0e 100644
--- 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 c54241c1a4..332209aeb9 100644
--- 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 2552ff4fb3..69f8cba43d 100644
--- 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 4a73e66b99..1c6588287a 100644
--- 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 3e0989ad46..9571b63b98 100644
--- 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);