Add noexcept

6 files changed, 24 insertions, 24 deletions

diff --git a/vespalib/src/vespa/vespalib/data/slime/root_value.h b/vespalib/src/vespa/vespalib/data/slime/root_value.h
index b61325e9cd0..1a7f8115015 100644
--- a/vespalib/src/vespa/vespalib/data/slime/root_value.h
+++ b/vespalib/src/vespa/vespalib/data/slime/root_value.h
@@ -14,21 +14,21 @@ private:
     Stash *_stash;
 
 public:
-    RootValue(Stash * stash) : _value(NixValue::instance()), _stash(stash) {}
-    RootValue(RootValue && rhs) : _value(rhs._value), _stash(rhs._stash) {
+    RootValue(Stash * stash) noexcept : _value(NixValue::instance()), _stash(stash) {}
+    RootValue(RootValue && rhs) noexcept : _value(rhs._value), _stash(rhs._stash) {
         rhs._value = NixValue::instance();
         rhs._stash = nullptr;
     }
     RootValue(const RootValue &) = delete;
     RootValue &operator=(const RootValue &) = delete;
-    RootValue &operator=(RootValue && rhs) {
+    RootValue &operator=(RootValue && rhs) noexcept {
         _value = rhs._value;
         _stash = rhs._stash;
         rhs._value = NixValue::instance();
         rhs._stash = nullptr;
         return *this;
     }
-    Cursor &get() const { return *_value; }
+    Cursor &get() const noexcept { return *_value; }
     Cursor &set(const ValueFactory &input) {
         Value *value = input.create(*_stash);
         _value = value;
diff --git a/vespalib/src/vespa/vespalib/data/slime/slime.cpp b/vespalib/src/vespa/vespalib/data/slime/slime.cpp
index 272fbdbf42e..d6fac44b360 100644
--- a/vespalib/src/vespa/vespalib/data/slime/slime.cpp
+++ b/vespalib/src/vespa/vespalib/data/slime/slime.cpp
@@ -7,7 +7,7 @@
 namespace vespalib {
 
 Slime::Params::Params() : Params(std::make_unique<SymbolTable>()) { }
-Slime::Params::Params(std::unique_ptr<SymbolTable> symbols) : _symbols(std::move(symbols)), _chunkSize(4096) { }
+Slime::Params::Params(std::unique_ptr<SymbolTable> symbols) noexcept : _symbols(std::move(symbols)), _chunkSize(4096) { }
 Slime::Params::Params(Params &&) noexcept = default;
 Slime::Params::~Params() = default;
 
@@ -23,7 +23,7 @@ Slime::Slime(Params params)
 { }
 
 Slime::Slime(Slime &&rhs) noexcept = default;
-Slime & Slime::operator=(Slime &&rhs) = default;
+Slime & Slime::operator=(Slime &&rhs) noexcept = default;
 Slime::~Slime() = default;
 
 std::unique_ptr<slime::SymbolTable>
@@ -34,7 +34,7 @@ Slime::reclaimSymbols(Slime &&rhs) {
 }
 
 size_t
-Slime::symbols() const {
+Slime::symbols() const noexcept {
     return _names->symbols();
 }
 
@@ -53,7 +53,7 @@ Slime::lookup(Memory name) const {
     return _names->lookup(name);
 }
 
-bool operator == (const Slime & a, const Slime & b)
+bool operator == (const Slime & a, const Slime & b) noexcept
 {
     return a.get() == b.get();
 }
diff --git a/vespalib/src/vespa/vespalib/data/slime/slime.h b/vespalib/src/vespa/vespalib/data/slime/slime.h
index a63a3e0ee06..028133d7be1 100644
--- a/vespalib/src/vespa/vespalib/data/slime/slime.h
+++ b/vespalib/src/vespa/vespalib/data/slime/slime.h
@@ -63,7 +63,7 @@ public:
         size_t                        _chunkSize;
     public:
         Params();
-        explicit Params(std::unique_ptr<SymbolTable> symbols);
+        explicit Params(std::unique_ptr<SymbolTable> symbols) noexcept;
         Params(Params &&) noexcept;
         ~Params();
         Params & setChunkSize(size_t chunkSize) {
@@ -81,14 +81,14 @@ public:
     ~Slime();
 
     Slime(Slime &&rhs) noexcept;
-    Slime &operator=(Slime &&rhs);
+    Slime &operator=(Slime &&rhs) noexcept;
 
     Slime(const Slime & rhs) = delete;
     Slime& operator = (const Slime & rhs) = delete;
 
     static std::unique_ptr<SymbolTable> reclaimSymbols(Slime &&rhs);
 
-    size_t symbols() const;
+    size_t symbols() const noexcept;
 
     Memory inspect(Symbol symbol) const;
 
@@ -96,9 +96,9 @@ public:
 
     Symbol lookup(Memory name) const;
 
-    Cursor &get() { return _root.get(); }
+    Cursor &get() noexcept { return _root.get(); }
 
-    Inspector &get() const { return _root.get(); }
+    Inspector &get() const noexcept { return _root.get(); }
 
     template <typename ID>
     Inspector &operator[](ID id) const { return get()[id]; }
@@ -150,7 +150,7 @@ public:
     vespalib::string toString() const { return get().toString(); }
 };
 
-bool operator == (const Slime & a, const Slime & b);
+bool operator == (const Slime & a, const Slime & b) noexcept;
 std::ostream & operator << (std::ostream & os, const Slime & slime);
 
 } // namespace vespalib
diff --git a/vespalib/src/vespa/vespalib/data/slime/symbol_table.h b/vespalib/src/vespa/vespalib/data/slime/symbol_table.h
index 40200faaca7..2ad983b140c 100644
--- a/vespalib/src/vespa/vespalib/data/slime/symbol_table.h
+++ b/vespalib/src/vespa/vespalib/data/slime/symbol_table.h
@@ -29,7 +29,7 @@ public:
     typedef std::unique_ptr<SymbolTable> UP;
     SymbolTable(size_t expectedNumSymbols=16);
     ~SymbolTable();
-    size_t symbols() const { return _names.size(); }
+    size_t symbols() const noexcept { return _names.size(); }
     Memory inspect(const Symbol &symbol) const {
         if (symbol.getValue() > _names.size()) {
             return Memory();
diff --git a/vespalib/src/vespa/vespalib/data/slime/type.h b/vespalib/src/vespa/vespalib/data/slime/type.h
index 915e80ca7f7..50789d3f53b 100644
--- a/vespalib/src/vespa/vespalib/data/slime/type.h
+++ b/vespalib/src/vespa/vespalib/data/slime/type.h
@@ -15,10 +15,10 @@ private:
     uint32_t _id;
 
 protected:
-    Type(uint32_t id) : _id(id) {}
+    Type(uint32_t id) noexcept : _id(id) {}
 
 public:
-    uint32_t getId() const { return _id; }
+    uint32_t getId() const noexcept { return _id; }
 };
 
 /**
diff --git a/vespalib/src/vespa/vespalib/util/stash.h b/vespalib/src/vespa/vespalib/util/stash.h
index 50945bf3cf2..11731e69217 100644
--- a/vespalib/src/vespa/vespalib/util/stash.h
+++ b/vespalib/src/vespa/vespalib/util/stash.h
@@ -48,9 +48,9 @@ struct Chunk {
     Chunk  *next;
     size_t  used;
     Chunk(const Chunk &) = delete;
-    explicit Chunk(Chunk *next_in) : next(next_in), used(sizeof(Chunk)) {}
-    void clear() { used = sizeof(Chunk); }
-    char *alloc(size_t size, size_t chunk_size) {
+    explicit Chunk(Chunk *next_in) noexcept : next(next_in), used(sizeof(Chunk)) {}
+    void clear() noexcept { used = sizeof(Chunk); }
+    char *alloc(size_t size, size_t chunk_size) noexcept {
         size_t aligned_size = ((size + (sizeof(char *) - 1))
                               & ~(sizeof(char *) - 1));
         if (used + aligned_size > chunk_size) {
@@ -84,7 +84,7 @@ private:
     size_t          _chunk_size;
 
     char *do_alloc(size_t size);
-    bool is_small(size_t size) const { return (size < (_chunk_size / 4)); }
+    bool is_small(size_t size) const noexcept { return (size < (_chunk_size / 4)); }
 
     template <typename T, typename ... Args>
     T *init_array(char *mem, size_t size, Args && ... args) {
@@ -119,10 +119,10 @@ public:
         stash::Cleanup *_cleanup;
         stash::Chunk   *_chunk;
         size_t          _used;
-        Mark(stash::Cleanup *cleanup, stash::Chunk *chunk)
+        Mark(stash::Cleanup *cleanup, stash::Chunk *chunk) noexcept
             : _cleanup(cleanup), _chunk(chunk), _used(chunk ? chunk->used : 0u) {}
     public:
-        Mark() : Mark(nullptr, nullptr) {}
+        Mark() noexcept : Mark(nullptr, nullptr) {}
     };
 
     typedef std::unique_ptr<Stash> UP;
@@ -137,7 +137,7 @@ public:
 
     void clear();
 
-    Mark mark() const { return Mark(_cleanup, _chunks); }
+    Mark mark() const noexcept { return Mark(_cleanup, _chunks); }
     void revert(const Mark &mark);
 
     size_t count_used() const;