Merge pull request #26439 from vespa-engine/balder/add-noexcept

Add noexcept

3 files changed, 55 insertions, 56 deletions

diff --git a/vespalib/src/vespa/vespalib/util/array.h b/vespalib/src/vespa/vespalib/util/array.h
index e9d8c9ccfdb..7b23f6245c7 100644
--- a/vespalib/src/vespa/vespalib/util/array.h
+++ b/vespalib/src/vespa/vespalib/util/array.h
@@ -16,77 +16,76 @@ class Array {
 public:
     class reverse_iterator {
     public:
-        reverse_iterator() : _p(NULL) { }
-        reverse_iterator(T * p) : _p(p) { }
-        T & operator   *() { return _p[0]; }
-        T * operator -> () { return _p; }
-        reverse_iterator operator -(size_t n) { return _p + n; }
-        reverse_iterator operator +(size_t n) { return _p - n; }
-        reverse_iterator & operator ++ () {
+        reverse_iterator() noexcept : _p(nullptr) { }
+        reverse_iterator(T * p) noexcept : _p(p) { }
+        T & operator   *() noexcept { return _p[0]; }
+        T * operator -> () noexcept { return _p; }
+        reverse_iterator operator -(size_t n) noexcept { return _p + n; }
+        reverse_iterator operator +(size_t n) noexcept { return _p - n; }
+        reverse_iterator & operator ++ () noexcept {
             _p--;
             return *this;
         }
-        reverse_iterator operator ++ (int) {
+        reverse_iterator operator ++ (int) noexcept {
             reverse_iterator prev = *this;
             _p--;
             return prev;
         }
-        reverse_iterator & operator -- () {
+        reverse_iterator & operator -- () noexcept {
             _p++;
             return *this;
         }
-        reverse_iterator operator -- (int) {
+        reverse_iterator operator -- (int) noexcept {
             reverse_iterator prev = *this;
             _p++;
             return prev;
         }
-        T * get() { return _p; }
+        T * get() noexcept { return _p; }
     private:
-        friend size_t operator -(reverse_iterator a, reverse_iterator b) { return b._p - a._p; }
+        friend size_t operator -(reverse_iterator a, reverse_iterator b) noexcept { return b._p - a._p; }
         T * _p;
     };
     class const_reverse_iterator {
     public:
-        const_reverse_iterator() : _p(NULL) { }
-        const_reverse_iterator(const T * p) : _p(p) { }
-        const_reverse_iterator(reverse_iterator i) : _p(i.get()) { }
-        const T & operator   *() const { return _p[0]; }
-        const T * operator -> () const { return _p; }
-        const_reverse_iterator operator -(size_t n) { return _p + n; }
-        const_reverse_iterator operator +(size_t n) { return _p - n; }
-        const_reverse_iterator & operator ++ () {
+        const_reverse_iterator() noexcept : _p(nullptr) { }
+        const_reverse_iterator(const T * p) noexcept : _p(p) { }
+        const_reverse_iterator(reverse_iterator i) noexcept : _p(i.get()) { }
+        const T & operator   *() const noexcept { return _p[0]; }
+        const T * operator -> () const noexcept { return _p; }
+        const_reverse_iterator operator -(size_t n) noexcept { return _p + n; }
+        const_reverse_iterator operator +(size_t n) noexcept { return _p - n; }
+        const_reverse_iterator & operator ++ () noexcept {
             _p--;
             return *this;
         }
-        const_reverse_iterator operator ++ (int) {
+        const_reverse_iterator operator ++ (int) noexcept {
             const_reverse_iterator prev = *this;
             _p--;
             return prev;
         }
-        const_reverse_iterator & operator -- () {
+        const_reverse_iterator & operator -- () noexcept {
             _p++;
             return *this;
         }
-        const_reverse_iterator operator -- (int) {
+        const_reverse_iterator operator -- (int) noexcept {
             const_reverse_iterator prev = *this;
             _p++;
             return prev;
         }
 
     private:
-        friend size_t operator -(const_reverse_iterator a, const_reverse_iterator b) { return b._p - a._p; }
+        friend size_t operator -(const_reverse_iterator a, const_reverse_iterator b) noexcept { return b._p - a._p; }
         const T * _p;
     };
     using Alloc = alloc::Alloc;
     using const_iterator = const T *;
     using iterator = T *;
-    using const_reference = const T &;
     using value_type = T;
     using size_type = size_t;
 
     Array(const Alloc & initial=Alloc::alloc());
     Array(size_t sz, const Alloc & initial=Alloc::alloc());
-    Array(Alloc && buf, size_t sz);
+    Array(Alloc && buf, size_t sz) noexcept;
     Array(Array &&rhs) noexcept;
     Array(size_t sz, T value, const Alloc & initial=Alloc::alloc());
     Array(const_iterator begin, const_iterator end, const Alloc & initial=Alloc::alloc());
@@ -94,7 +93,7 @@ public:
     Array & operator =(const Array & rhs);
     Array & operator =(Array && rhs) noexcept;
     ~Array();
-    void swap(Array & rhs) {
+    void swap(Array & rhs) noexcept {
         _array.swap(rhs._array);
         std::swap(_sz, rhs._sz);
     }
@@ -117,39 +116,39 @@ public:
         std::destroy_at(array(_sz));
     }
 
-    T & back()                              { return *array(_sz-1); }
-    const T & back()                  const { return *array(_sz-1); }
-    const_iterator begin()            const { return array(0); }
-    const_iterator end()              const { return array(_sz); }
-    iterator begin()                        { return array(0); }
-    iterator end()                          { return array(_sz); }
-    const_reverse_iterator rbegin()   const { return empty() ? array(0) : array(_sz) - 1; }
-    const_reverse_iterator rend()     const { return empty() ? array(0) : array(0) - 1; }
-    reverse_iterator rbegin()               { return empty() ? array(0) : array(_sz) - 1; }
-    reverse_iterator rend()                 { return empty() ? array(0) : array(0) - 1; }
-    size_t size() const                     { return _sz; }
-    size_t capacity() const                 { return _array.size()/sizeof(T); }
+    T & back()                              noexcept { return *array(_sz-1); }
+    const T & back()                  const noexcept { return *array(_sz-1); }
+    const_iterator begin()            const noexcept { return array(0); }
+    const_iterator end()              const noexcept { return array(_sz); }
+    iterator begin()                        noexcept { return array(0); }
+    iterator end()                          noexcept { return array(_sz); }
+    const_reverse_iterator rbegin()   const noexcept { return empty() ? array(0) : array(_sz) - 1; }
+    const_reverse_iterator rend()     const noexcept { return empty() ? array(0) : array(0) - 1; }
+    reverse_iterator rbegin()               noexcept { return empty() ? array(0) : array(_sz) - 1; }
+    reverse_iterator rend()                 noexcept { return empty() ? array(0) : array(0) - 1; }
+    size_t size()                     const noexcept { return _sz; }
+    size_t capacity()                 const noexcept { return _array.size()/sizeof(T); }
     void clear() {
         std::destroy(array(0), array(_sz));
         _sz = 0;
     }
     void reset();
-    bool empty() const                      { return _sz == 0; }
-    T * data() noexcept                     { return static_cast<T *>(_array.get()); }
-    const T * data() const noexcept         { return static_cast<const T *>(_array.get()); }
-    T & operator [] (size_t i)              { return *array(i); }
-    const T & operator [] (size_t i) const  { return *array(i); }
-    bool operator == (const Array & rhs) const;
-    bool operator != (const Array & rhs) const;
+    bool empty()                         const noexcept { return _sz == 0; }
+    T * data()                                 noexcept { return static_cast<T *>(_array.get()); }
+    const T * data()                     const noexcept { return static_cast<const T *>(_array.get()); }
+    T & operator [] (size_t i)                 noexcept { return *array(i); }
+    const T & operator [] (size_t i)     const noexcept { return *array(i); }
+    bool operator == (const Array & rhs) const noexcept;
+    bool operator != (const Array & rhs) const noexcept;
 
-    static Alloc stealAlloc(Array && rhs) {
+    static Alloc stealAlloc(Array && rhs)  noexcept {
         rhs._sz = 0;
         return std::move(rhs._array);
     }
     Array<T> create() const;
 private:
-    T *       array(size_t i)       { return static_cast<T *>(_array.get()) + i; }
-    const T * array(size_t i) const { return static_cast<const T *>(_array.get()) + i; }
+    T *       array(size_t i)       noexcept { return static_cast<T *>(_array.get()) + i; }
+    const T * array(size_t i) const noexcept { return static_cast<const T *>(_array.get()) + i; }
     void cleanup();
     void increase(size_t n);
     void extend(size_t n) {
diff --git a/vespalib/src/vespa/vespalib/util/array.hpp b/vespalib/src/vespa/vespalib/util/array.hpp
index 24136e544b8..a68aca1ddb0 100644
--- a/vespalib/src/vespa/vespalib/util/array.hpp
+++ b/vespalib/src/vespa/vespalib/util/array.hpp
@@ -17,7 +17,7 @@ void construct(T * dest, const T * source, size_t sz, std::false_type)
 }
 
 template <typename T>
-void construct(T * dest, const T * source, size_t sz, std::true_type)
+void construct(T * dest, const T * source, size_t sz, std::true_type) noexcept
 {
     memcpy(dest, source, sz*sizeof(T));
 }
@@ -32,7 +32,7 @@ void construct(T * dest, size_t sz, std::false_type)
 }
 
 template <typename T>
-void construct(T * dest, size_t sz, std::true_type)
+void construct(T * dest, size_t sz, std::true_type) noexcept
 {
     (void) dest;
     (void) sz;
@@ -123,7 +123,7 @@ void Array<T>::resize(size_t n)
 }
 
 template <typename T>
-void move(T * dest, T * source, size_t sz, std::false_type)
+void move(T * dest, T * source, size_t sz, std::false_type) noexcept
 {
     for (size_t i(0); i < sz; i++) {
         ::new (static_cast<void *>(dest + i)) T(std::move(*(source + i)));
@@ -132,7 +132,7 @@ void move(T * dest, T * source, size_t sz, std::false_type)
 }
 
 template <typename T>
-void move(T * dest, const T * source, size_t sz, std::true_type)
+void move(T * dest, const T * source, size_t sz, std::true_type) noexcept
 {
     memcpy(dest, source, sz*sizeof(T));
 }
@@ -154,7 +154,7 @@ Array<T>::Array(const Alloc & initial)
 { }
 
 template <typename T>
-Array<T>::Array(Alloc && buf, size_t sz) :
+Array<T>::Array(Alloc && buf, size_t sz) noexcept :
     _array(std::move(buf)),
     _sz(sz)
 {
diff --git a/vespalib/src/vespa/vespalib/util/array_equal.hpp b/vespalib/src/vespa/vespalib/util/array_equal.hpp
index 3b3aab6280b..3e7e624b6e9 100644
--- a/vespalib/src/vespa/vespalib/util/array_equal.hpp
+++ b/vespalib/src/vespa/vespalib/util/array_equal.hpp
@@ -6,7 +6,7 @@
 namespace vespalib {
 
 template <typename T>
-bool Array<T>::operator ==(const Array & rhs) const
+bool Array<T>::operator ==(const Array & rhs) const noexcept
 {
     bool retval(size() == rhs.size());
     for (size_t i(0); retval && (i < _sz); i++) {
@@ -18,7 +18,7 @@ bool Array<T>::operator ==(const Array & rhs) const
 }
 
 template <typename T>
-bool Array<T>::operator != (const Array & rhs) const {
+bool Array<T>::operator != (const Array & rhs) const noexcept {
     return !(*this == rhs);
 }