Add noexcept

2 files changed, 29 insertions, 29 deletions

diff --git a/vespalib/src/vespa/vespalib/datastore/buffer_stats.cpp b/vespalib/src/vespa/vespalib/datastore/buffer_stats.cpp
index b1fd6460d24..5705d9faefc 100644
--- a/vespalib/src/vespa/vespalib/datastore/buffer_stats.cpp
+++ b/vespalib/src/vespa/vespalib/datastore/buffer_stats.cpp
@@ -5,7 +5,7 @@
 
 namespace vespalib::datastore {
 
-BufferStats::BufferStats()
+BufferStats::BufferStats() noexcept
     : _alloc_entries(0),
       _used_entries(0),
       _hold_entries(0),
@@ -16,7 +16,7 @@ BufferStats::BufferStats()
 }
 
 void
-BufferStats::add_to_mem_stats(size_t entry_size, MemoryStats& stats) const
+BufferStats::add_to_mem_stats(size_t entry_size, MemoryStats& stats) const noexcept
 {
     size_t extra_used = extra_used_bytes();
     stats._alloc_entries += capacity();
@@ -29,13 +29,13 @@ BufferStats::add_to_mem_stats(size_t entry_size, MemoryStats& stats) const
     stats._holdBytes += (hold_entries() * entry_size) + extra_hold_bytes();
 }
 
-InternalBufferStats::InternalBufferStats()
+InternalBufferStats::InternalBufferStats() noexcept
     : BufferStats()
 {
 }
 
 void
-InternalBufferStats::clear()
+InternalBufferStats::clear() noexcept
 {
     _alloc_entries.store(0, std::memory_order_relaxed);
     _used_entries.store(0, std::memory_order_relaxed);
@@ -46,7 +46,7 @@ InternalBufferStats::clear()
 }
 
 void
-InternalBufferStats::dec_hold_entries(size_t value)
+InternalBufferStats::dec_hold_entries(size_t value) noexcept
 {
     EntryCount elems = hold_entries();
     assert(elems >= value);
diff --git a/vespalib/src/vespa/vespalib/datastore/buffer_stats.h b/vespalib/src/vespa/vespalib/datastore/buffer_stats.h
index 12ac8ae4995..59446ddc989 100644
--- a/vespalib/src/vespa/vespalib/datastore/buffer_stats.h
+++ b/vespalib/src/vespa/vespalib/datastore/buffer_stats.h
@@ -32,24 +32,24 @@ protected:
     std::atomic<size_t> _extra_hold_bytes;
 
 public:
-    BufferStats();
+    BufferStats() noexcept;
 
-    size_t size() const { return _used_entries.load(std::memory_order_relaxed); }
-    size_t capacity() const { return _alloc_entries.load(std::memory_order_relaxed); }
-    size_t remaining() const { return capacity() - size(); }
+    size_t size() const noexcept { return _used_entries.load(std::memory_order_relaxed); }
+    size_t capacity() const noexcept { return _alloc_entries.load(std::memory_order_relaxed); }
+    size_t remaining() const noexcept { return capacity() - size(); }
 
-    void pushed_back(size_t num_entries) {
+    void pushed_back(size_t num_entries) noexcept {
         _used_entries.store(size() + num_entries, std::memory_order_relaxed);
     }
 
-    size_t dead_entries() const { return _dead_entries.load(std::memory_order_relaxed); }
-    size_t hold_entries() const { return _hold_entries.load(std::memory_order_relaxed); }
-    size_t extra_used_bytes() const { return _extra_used_bytes.load(std::memory_order_relaxed); }
-    size_t extra_hold_bytes() const { return _extra_hold_bytes.load(std::memory_order_relaxed); }
+    size_t dead_entries() const noexcept { return _dead_entries.load(std::memory_order_relaxed); }
+    size_t hold_entries() const noexcept { return _hold_entries.load(std::memory_order_relaxed); }
+    size_t extra_used_bytes() const noexcept { return _extra_used_bytes.load(std::memory_order_relaxed); }
+    size_t extra_hold_bytes() const noexcept { return _extra_hold_bytes.load(std::memory_order_relaxed); }
 
-    void inc_extra_used_bytes(size_t value) { _extra_used_bytes.store(extra_used_bytes() + value, std::memory_order_relaxed); }
+    void inc_extra_used_bytes(size_t value) noexcept { _extra_used_bytes.store(extra_used_bytes() + value, std::memory_order_relaxed); }
 
-    void add_to_mem_stats(size_t entry_size, MemoryStats& stats) const;
+    void add_to_mem_stats(size_t entry_size, MemoryStats& stats) const noexcept;
 };
 
 /**
@@ -57,19 +57,19 @@ public:
  */
 class InternalBufferStats : public BufferStats {
 public:
-    InternalBufferStats();
-    void clear();
-    void set_alloc_entries(size_t value) { _alloc_entries.store(value, std::memory_order_relaxed); }
-    void set_dead_entries(size_t value) { _dead_entries.store(value, std::memory_order_relaxed); }
-    void set_hold_entries(size_t value) { _hold_entries.store(value, std::memory_order_relaxed); }
-    void inc_dead_entries(size_t value) { _dead_entries.store(dead_entries() + value, std::memory_order_relaxed); }
-    void inc_hold_entries(size_t value) { _hold_entries.store(hold_entries() + value, std::memory_order_relaxed); }
-    void dec_hold_entries(size_t value);
-    void inc_extra_hold_bytes(size_t value) { _extra_hold_bytes.store(extra_hold_bytes() + value, std::memory_order_relaxed); }
-    std::atomic<EntryCount>& used_entries_ref() { return _used_entries; }
-    std::atomic<EntryCount>& dead_entries_ref() { return _dead_entries; }
-    std::atomic<size_t>& extra_used_bytes_ref() { return _extra_used_bytes; }
-    std::atomic<size_t>& extra_hold_bytes_ref() { return _extra_hold_bytes; }
+    InternalBufferStats() noexcept;
+    void clear() noexcept;
+    void set_alloc_entries(size_t value) noexcept { _alloc_entries.store(value, std::memory_order_relaxed); }
+    void set_dead_entries(size_t value) noexcept { _dead_entries.store(value, std::memory_order_relaxed); }
+    void set_hold_entries(size_t value) noexcept { _hold_entries.store(value, std::memory_order_relaxed); }
+    void inc_dead_entries(size_t value) noexcept { _dead_entries.store(dead_entries() + value, std::memory_order_relaxed); }
+    void inc_hold_entries(size_t value) noexcept { _hold_entries.store(hold_entries() + value, std::memory_order_relaxed); }
+    void dec_hold_entries(size_t value) noexcept;
+    void inc_extra_hold_bytes(size_t value) noexcept { _extra_hold_bytes.store(extra_hold_bytes() + value, std::memory_order_relaxed); }
+    std::atomic<EntryCount>& used_entries_ref() noexcept { return _used_entries; }
+    std::atomic<EntryCount>& dead_entries_ref() noexcept { return _dead_entries; }
+    std::atomic<size_t>& extra_used_bytes_ref() noexcept { return _extra_used_bytes; }
+    std::atomic<size_t>& extra_hold_bytes_ref() noexcept { return _extra_hold_bytes; }
 };
 
 }