Make vespalib hash functors noexcept

Make ducktyped functor conditionally noexcept on `hash()` member function.
Follow up on `-Werror=noexcept` warnings indicating where `noexcept` can
be trivially added for such functions.

2 files changed, 26 insertions, 26 deletions

diff --git a/vespalib/src/vespa/vespalib/stllike/hash_fun.cpp b/vespalib/src/vespa/vespalib/stllike/hash_fun.cpp
index 5f4fee06c4a..f057a229098 100644
--- a/vespalib/src/vespa/vespalib/stllike/hash_fun.cpp
+++ b/vespalib/src/vespa/vespalib/stllike/hash_fun.cpp
@@ -6,7 +6,7 @@
 namespace vespalib {
 
 size_t
-hashValue(const char *str)
+hashValue(const char *str) noexcept
 {
     return hashValue(str, strlen(str));
 }
@@ -20,7 +20,7 @@ hashValue(const char *str)
  * @return hash value of input
  **/
 size_t
-hashValue(const void * buf, size_t sz)
+hashValue(const void * buf, size_t sz) noexcept
 {
     return XXH64(buf, sz, 0);
 }
diff --git a/vespalib/src/vespa/vespalib/stllike/hash_fun.h b/vespalib/src/vespa/vespalib/stllike/hash_fun.h
index c5f239f2b4e..089e8b14039 100644
--- a/vespalib/src/vespa/vespalib/stllike/hash_fun.h
+++ b/vespalib/src/vespa/vespalib/stllike/hash_fun.h
@@ -8,71 +8,71 @@ namespace vespalib {
 
 template<typename K> struct hash {
     // specializations operate as functor for known key types
-    size_t operator() (const K & v) const {
+    size_t operator() (const K & v) const noexcept(noexcept(v.hash())) {
         return v.hash();
     }
 };
 
 template<> struct hash<char> {
-    size_t operator() (char arg) const { return arg; }
+    size_t operator() (char arg) const noexcept { return arg; }
 };
 template<> struct hash<signed char> {
-    size_t operator() (signed char arg) const { return arg; }
+    size_t operator() (signed char arg) const noexcept { return arg; }
 };
 template<> struct hash<short> {
-    size_t operator() (short arg) const { return arg; }
+    size_t operator() (short arg) const noexcept { return arg; }
 };
 template<> struct hash<int> {
-    size_t operator() (int arg) const { return arg; }
+    size_t operator() (int arg) const noexcept { return arg; }
 };
 template<> struct hash<long> {
-    size_t operator() (long arg) const { return arg; }
+    size_t operator() (long arg) const noexcept { return arg; }
 };
 template<> struct hash<long long> {
-    size_t operator() (long long arg) const { return arg; }
+    size_t operator() (long long arg) const noexcept { return arg; }
 };
 
 template<> struct hash<unsigned char> {
-    size_t operator() (unsigned char arg) const { return arg; }
+    size_t operator() (unsigned char arg) const noexcept { return arg; }
 };
 template<> struct hash<unsigned short> {
-    size_t operator() (unsigned short arg) const { return arg; }
+    size_t operator() (unsigned short arg) const noexcept { return arg; }
 };
 template<> struct hash<unsigned int> {
-    size_t operator() (unsigned int arg) const { return arg; }
+    size_t operator() (unsigned int arg) const noexcept { return arg; }
 };
 template<> struct hash<unsigned long> {
-    size_t operator() (unsigned long arg) const { return arg; }
+    size_t operator() (unsigned long arg) const noexcept { return arg; }
 };
 template<> struct hash<unsigned long long> {
-    size_t operator() (unsigned long long arg) const { return arg; }
+    size_t operator() (unsigned long long arg) const noexcept { return arg; }
 };
 
 template<> struct hash<float> {
     union U { float f; uint32_t i; };
-    size_t operator() (float arg) const { U t; t.f = arg; return t.i; }
+    size_t operator() (float arg) const noexcept { U t; t.f = arg; return t.i; }
 };
 template<> struct hash<double> {
     union U { double f; uint64_t i; };
-    size_t operator() (double arg) const { U t; t.f = arg; return t.i; }
+    size_t operator() (double arg) const noexcept { U t; t.f = arg; return t.i; }
 };
 
 template<typename T> struct hash<T *> {
-    size_t operator() (const T * arg) const { return size_t(arg); }
+    size_t operator() (const T * arg) const noexcept { return size_t(arg); }
 };
 template<typename T> struct hash<const T *> {
-    size_t operator() (const T * arg) const { return size_t(arg); }
+    size_t operator() (const T * arg) const noexcept { return size_t(arg); }
 };
 
 // reuse old string hash function
-size_t hashValue(const char *str);
-size_t hashValue(const void *str, size_t sz);
+size_t hashValue(const char *str) noexcept;
+size_t hashValue(const void *str, size_t sz) noexcept;
 
 struct hash_strings {
-    size_t operator() (const vespalib::string & arg) const { return hashValue(arg.c_str()); }
-    size_t operator() (vespalib::stringref arg) const { return hashValue(arg.data(), arg.size()); }
-    size_t operator() (const char * arg) const { return hashValue(arg); }
-    size_t operator() (const std::string& arg) const { return hashValue(arg.c_str()); }
+    size_t operator() (const vespalib::string & arg) const noexcept { return hashValue(arg.c_str()); }
+    size_t operator() (vespalib::stringref arg) const noexcept { return hashValue(arg.data(), arg.size()); }
+    size_t operator() (const char * arg) const noexcept { return hashValue(arg); }
+    size_t operator() (const std::string& arg) const noexcept { return hashValue(arg.c_str()); }
 };
 
 template<> struct hash<const char *> : hash_strings { };
@@ -81,11 +81,11 @@ template<> struct hash<vespalib::string> : hash_strings {};
 template<> struct hash<std::string> : hash_strings {};
 
 template<typename V> struct size {
-    size_t operator() (const V & arg) const { return arg.size(); }
+    size_t operator() (const V & arg) const noexcept { return arg.size(); }
 };
 
 template<typename V> struct zero {
-    size_t operator() (const V & ) const { return 0; }
+    size_t operator() (const V & ) const noexcept { return 0; }
 };
 
 } // namespace vespalib