Merge pull request #1939 from Flamefire/gcc-16

Flamefire · web-flow · commit d70b8eccf000 · 2026-06-25T20:05:46.000+02:00
GHA: Add GCC 16 to CI
diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
@@ -108,6 +108,7 @@ jobs:
           #   Use (compiler) default C++ 17 standard
           #   Use default cmake
           - { compiler: gcc-14,   os: ubuntu-24.04, type: Debug }
+          - { compiler: gcc-16,   os: ubuntu-24.04, type: Debug, "apt_key": "0x1E9377A2BA9EF27F", "apt_repo": "ppa:ubuntu-toolchain-r/test" }
           - { compiler: clang-18, os: ubuntu-24.04, type: Debug, externalSanitizer: true }
           - { compiler: clang-21, os: ubuntu-latest, type: Debug, init_llvm: true}
 
@@ -179,6 +180,12 @@ jobs:
               clang_version=${compiler#clang-*}
               wget -qO- "https://apt.llvm.org/llvm.sh" | sudo bash -s -- "${clang_version}"
             fi
+            if [[ -n "${{matrix.apt_key}}" ]]; then
+              tools/ci/add-apt-keys.sh "${{matrix.apt_key}}"
+            fi
+            if [[ -n "${{matrix.apt_repo}}" ]]; then
+              tools/ci/add-apt-repositories.sh "${{matrix.apt_repo}}"
+            fi
             sudo apt-get -o Acquire::Retries=5 update
             sudo apt-get -o Acquire::Retries=5 -y -q --no-install-suggests --no-install-recommends install gettext libsdl2-dev libsdl2-mixer-dev libcurl4-openssl-dev libbz2-dev libminiupnpc-dev liblua5.2-dev $compiler
           fi
diff --git a/external/libutil b/external/libutil
@@ -1 +1 @@
-Subproject commit 7fa45383c110b7b8cd486ceac92045e8a891b790
+Subproject commit 08e49918deae1e67ee4a0ddd6b290f5a59e13989
diff --git a/libs/common/include/Rect.h b/libs/common/include/Rect.h
@@ -43,11 +43,11 @@ struct RectBase
     void move(const position_type& offset);
     static RectBase move(RectBase rect, const position_type& offset);
 
-    constexpr bool operator==(const RectBase& rhs) const
+    constexpr bool operator==(const RectBase& rhs) const noexcept
     {
         return left == rhs.left && top == rhs.top && right == rhs.right && bottom == rhs.bottom;
     }
-    constexpr bool operator!=(const RectBase& rhs) const { return !(*this == rhs); }
+    constexpr bool operator!=(const RectBase& rhs) const noexcept { return !(*this == rhs); }
 };
 
 using Rect = RectBase<int>;
diff --git a/libs/common/include/helpers/EnumArray.h b/libs/common/include/helpers/EnumArray.h
@@ -33,7 +33,7 @@ struct EnumArray
     iterator end() noexcept { return elems + size(); }
     constexpr const_iterator end() const noexcept { return elems + size(); }
 
-    constexpr bool operator==(const EnumArray& rhs)
+    constexpr bool operator==(const EnumArray& rhs) noexcept
     {
         for(unsigned i = 0; i < size(); ++i)
         {
diff --git a/libs/common/include/helpers/OptionalEnum.h b/libs/common/include/helpers/OptionalEnum.h
@@ -48,23 +48,23 @@ class OptionalEnum
     constexpr void reset() noexcept { value_ = invalidValue; }
 
     // Those comparisons can be simplified to comparing value_ due to the invalid value being a distinct value
-    friend constexpr bool operator==(OptionalEnum lhs, OptionalEnum rhs) { return lhs.value_ == rhs.value_; }
-    friend constexpr bool operator!=(OptionalEnum lhs, OptionalEnum rhs) { return lhs.value_ != rhs.value_; }
+    friend constexpr bool operator==(OptionalEnum lhs, OptionalEnum rhs) noexcept { return lhs.value_ == rhs.value_; }
+    friend constexpr bool operator!=(OptionalEnum lhs, OptionalEnum rhs) noexcept { return lhs.value_ != rhs.value_; }
     // Technically not required as above operators would be used, but included for better debug performance and
     // mirroring the standard
-    friend constexpr bool operator==(OptionalEnum lhs, const T& rhs)
+    friend constexpr bool operator==(OptionalEnum lhs, const T& rhs) noexcept
     {
         return lhs.value_ == static_cast<underlying_type>(rhs);
     }
-    friend constexpr bool operator!=(OptionalEnum lhs, const T& rhs)
+    friend constexpr bool operator!=(OptionalEnum lhs, const T& rhs) noexcept
     {
         return lhs.value_ != static_cast<underlying_type>(rhs);
     }
-    friend constexpr bool operator==(const T& lhs, OptionalEnum rhs)
+    friend constexpr bool operator==(const T& lhs, OptionalEnum rhs) noexcept
     {
         return static_cast<underlying_type>(lhs) == rhs.value_;
     }
-    friend constexpr bool operator!=(const T& lhs, OptionalEnum rhs)
+    friend constexpr bool operator!=(const T& lhs, OptionalEnum rhs) noexcept
     {
         return static_cast<underlying_type>(lhs) != rhs.value_;
     }
diff --git a/libs/common/include/helpers/PtrSpan.h b/libs/common/include/helpers/PtrSpan.h
@@ -45,8 +45,8 @@ class NonNullPtrSpan
         using reference = value_type&;
 
         RTTR_CONSTEXPR_INLINE explicit Iterator(RangeIterator it) : it(std::move(it)) {}
-        RTTR_CONSTEXPR_INLINE bool operator==(const Iterator& other) const { return it == other.it; }
-        RTTR_CONSTEXPR_INLINE bool operator!=(const Iterator& other) const { return it != other.it; }
+        RTTR_CONSTEXPR_INLINE bool operator==(const Iterator& other) const noexcept { return it == other.it; }
+        RTTR_CONSTEXPR_INLINE bool operator!=(const Iterator& other) const noexcept { return it != other.it; }
         RTTR_CONSTEXPR_INLINE reference operator*() const { return **it; }
         RTTR_CONSTEXPR_INLINE pointer operator->() const { return &(**it); }
         RTTR_CONSTEXPR_INLINE Iterator& operator++()
diff --git a/libs/common/include/helpers/StrongId.h b/libs/common/include/helpers/StrongId.h
@@ -43,8 +43,8 @@ class StrongId
 
     explicit constexpr operator Underlying() const { return value_; }
 
-    friend constexpr bool operator==(const StrongId r, const StrongId l) { return r.value_ == l.value_; };
-    friend constexpr bool operator!=(const StrongId r, const StrongId l) { return r.value_ != l.value_; };
+    friend constexpr bool operator==(const StrongId r, const StrongId l) noexcept { return r.value_ == l.value_; };
+    friend constexpr bool operator!=(const StrongId r, const StrongId l) noexcept { return r.value_ != l.value_; };
 
     friend std::ostream& operator<<(std::ostream& os, const StrongId t) { return os << t.value_; }
 
diff --git a/libs/driver/include/driver/RawSoundHandle.h b/libs/driver/include/driver/RawSoundHandle.h
@@ -27,8 +27,8 @@ struct RawSoundHandle
     SoundType getType() const { return type; }
 
     // Comparison only compares the driver data
-    bool operator==(const RawSoundHandle& rhs) const { return driverData == rhs.driverData; }
-    bool operator!=(const RawSoundHandle& rhs) const { return driverData == rhs.driverData; }
+    bool operator==(const RawSoundHandle& rhs) const noexcept { return driverData == rhs.driverData; }
+    bool operator!=(const RawSoundHandle& rhs) const noexcept { return driverData != rhs.driverData; }
 
 private:
     // Only AudioDriver may create this to enforce registration and only it may reset the driverData
diff --git a/libs/driver/include/driver/VideoMode.h b/libs/driver/include/driver/VideoMode.h
@@ -12,8 +12,8 @@ struct VideoMode
 
     constexpr VideoMode() : width(0), height(0) {}
     constexpr VideoMode(unsigned short width, unsigned short height) : width(width), height(height) {}
-    constexpr bool operator==(const VideoMode& o) const { return (width == o.width && height == o.height); }
-    constexpr bool operator!=(const VideoMode& o) const { return !(*this == o); }
+    constexpr bool operator==(const VideoMode& o) const noexcept { return (width == o.width && height == o.height); }
+    constexpr bool operator!=(const VideoMode& o) const noexcept { return !(*this == o); }
     constexpr bool operator<(const VideoMode& o) const
     {
         if(width != o.width)
@@ -36,10 +36,13 @@ struct DisplayMode
     constexpr DisplayMode() = default;
     constexpr DisplayMode(Type t) : type(t) {}
     constexpr explicit DisplayMode(unsigned t) : type(Type(t)) {}
-    constexpr bool operator==(const Type& t) const { return type == t; }
-    constexpr bool operator!=(const Type& t) const { return type != t; }
-    constexpr bool operator==(const DisplayMode& o) const { return o.type == type && o.resizeable == resizeable; }
-    constexpr bool operator!=(const DisplayMode& o) const { return !(o == *this); }
+    constexpr bool operator==(const Type& t) const noexcept { return type == t; }
+    constexpr bool operator!=(const Type& t) const noexcept { return type != t; }
+    constexpr bool operator==(const DisplayMode& o) const noexcept
+    {
+        return o.type == type && o.resizeable == resizeable;
+    }
+    constexpr bool operator!=(const DisplayMode& o) const noexcept { return !(o == *this); }
 };
 
 constexpr auto maxEnumValue(DisplayMode::Type)
diff --git a/libs/s25main/AsyncChecksum.h b/libs/s25main/AsyncChecksum.h
@@ -24,17 +24,17 @@ struct AsyncChecksum
 
     static AsyncChecksum create(const Game& game);
 
-    bool operator==(const AsyncChecksum& rhs) const;
-    bool operator!=(const AsyncChecksum& rhs) const;
+    bool operator==(const AsyncChecksum& rhs) const noexcept;
+    bool operator!=(const AsyncChecksum& rhs) const noexcept;
 };
 
-inline bool AsyncChecksum::operator==(const AsyncChecksum& rhs) const
+inline bool AsyncChecksum::operator==(const AsyncChecksum& rhs) const noexcept
 {
     return randChecksum == rhs.randChecksum && objCt == rhs.objCt && objIdCt == rhs.objIdCt && eventCt == rhs.eventCt
            && evInstanceCt == rhs.evInstanceCt;
 }
 
-inline bool AsyncChecksum::operator!=(const AsyncChecksum& rhs) const
+inline bool AsyncChecksum::operator!=(const AsyncChecksum& rhs) const noexcept
 {
     return !(*this == rhs);
 }
diff --git a/libs/s25main/ai/AIResource.h b/libs/s25main/ai/AIResource.h
@@ -81,7 +81,7 @@ constexpr AINodeResource convertToNodeResource(AISubSurfaceResource res)
     return static_cast<AINodeResource>(static_cast<unsigned>(res));
 }
 
-constexpr bool operator==(AINodeResource lhs, AIResource rhs)
+constexpr bool operator==(AINodeResource lhs, AIResource rhs) noexcept
 {
     return lhs == convertToNodeResource(rhs);
 }
diff --git a/libs/s25main/buildings/nobHarborBuilding.h b/libs/s25main/buildings/nobHarborBuilding.h
@@ -184,7 +184,7 @@ class nobHarborBuilding : public nobBaseWarehouse
         {
             const nobMilitary* const search;
             CmpBuilding(const nobMilitary* const search) : search(search) {}
-            bool operator()(const SeaAttackerBuilding& other) const { return other.building == search; }
+            bool operator()(const SeaAttackerBuilding& other) const noexcept { return other.building == search; }
         };
         /// Das Gebäude selbst
         nobMilitary* building;
@@ -193,7 +193,7 @@ class nobHarborBuilding : public nobBaseWarehouse
         /// Entfernung Hafen - anderer Hafen
         unsigned distance;
 
-        bool operator==(const nobMilitary* const building) const { return (this->building == building); };
+        bool operator==(const nobMilitary* const building) const noexcept { return (this->building == building); };
     };
 
     /// Gibt die Angreifer zurück, die dieser Hafen für einen Seeangriff zur Verfügung stellen kann
diff --git a/libs/s25main/controls/ctrlMultiline.h b/libs/s25main/controls/ctrlMultiline.h
@@ -57,7 +57,7 @@ class ctrlMultiline : public Window
     {
         std::string str;
         unsigned color;
-        Line() : color(0) {}
+        Line() noexcept : color(0) {}
         Line(std::string str, unsigned color) : str(std::move(str)), color(color) {}
     };
 
diff --git a/libs/s25main/gameTypes/AIInfo.h b/libs/s25main/gameTypes/AIInfo.h
@@ -37,6 +37,6 @@ struct Info
     Info(Serializer& ser);
     void serialize(Serializer& ser) const;
 
-    bool operator==(const Info& rhs) const { return type == rhs.type && level == rhs.level; }
+    bool operator==(const Info& rhs) const noexcept { return type == rhs.type && level == rhs.level; }
 };
 } // namespace AI
diff --git a/libs/s25main/gameTypes/InventorySetting.h b/libs/s25main/gameTypes/InventorySetting.h
@@ -23,7 +23,7 @@ struct InventorySetting
     constexpr InventorySetting Toggle(EInventorySetting setting) noexcept;
     constexpr void MakeValid() noexcept;
     constexpr explicit operator uint8_t() const noexcept { return state; }
-    friend constexpr bool operator==(const InventorySetting& lhs, const InventorySetting& rhs);
+    friend constexpr bool operator==(const InventorySetting& lhs, const InventorySetting& rhs) noexcept;
 
 private:
     static constexpr uint8_t MakeBitField(EInventorySetting setting) noexcept;
@@ -69,12 +69,12 @@ constexpr void InventorySetting::MakeValid() noexcept
     }
 }
 
-constexpr bool operator!=(const InventorySetting& lhs, const InventorySetting& rhs)
+constexpr bool operator!=(const InventorySetting& lhs, const InventorySetting& rhs) noexcept
 {
     return !(lhs == rhs);
 }
 
-constexpr bool operator==(const InventorySetting& lhs, const InventorySetting& rhs)
+constexpr bool operator==(const InventorySetting& lhs, const InventorySetting& rhs) noexcept
 {
     return lhs.state == rhs.state;
 }
diff --git a/libs/s25main/gameTypes/Resource.h b/libs/s25main/gameTypes/Resource.h
@@ -41,8 +41,8 @@ class Resource
     constexpr void setAmount(uint8_t newAmount);
     /// True if we have a non-zero amount of the given resource. Always false for Nothing
     constexpr bool has(ResourceType type) const { return getAmount() > 0u && getType() == type; }
-    constexpr bool operator==(Resource rhs) const { return value_ == rhs.value_; }
-    constexpr bool operator!=(Resource rhs) const { return !(*this == rhs); }
+    constexpr bool operator==(Resource rhs) const noexcept { return value_ == rhs.value_; }
+    constexpr bool operator!=(Resource rhs) const noexcept { return !(*this == rhs); }
 };
 
 constexpr Resource::Resource(ResourceType type, uint8_t amount)
diff --git a/libs/s25main/lua/LuaInterfaceSettings.cpp b/libs/s25main/lua/LuaInterfaceSettings.cpp
@@ -18,7 +18,7 @@
 struct AddonIdWrapper
 {
     AddonId value;
-    constexpr operator AddonId() const { return value; }
+    constexpr operator AddonId() const noexcept { return value; }
 };
 
 LuaInterfaceSettings::LuaInterfaceSettings(IGameLobbyController& lobbyServerController,
diff --git a/libs/s25main/random/DefaultLCG.h b/libs/s25main/random/DefaultLCG.h
@@ -44,8 +44,8 @@ class DefaultLCG
 private:
     friend std::ostream& operator<<(std::ostream& os, const DefaultLCG& obj);
     friend std::istream& operator>>(std::istream& is, DefaultLCG& obj);
-    friend bool operator==(const DefaultLCG& lhs, const DefaultLCG& rhs) { return lhs.state_ == rhs.state_; }
-    friend bool operator!=(const DefaultLCG& lhs, const DefaultLCG& rhs) { return !(lhs == rhs); }
+    friend bool operator==(const DefaultLCG& lhs, const DefaultLCG& rhs) noexcept { return lhs.state_ == rhs.state_; }
+    friend bool operator!=(const DefaultLCG& lhs, const DefaultLCG& rhs) noexcept { return !(lhs == rhs); }
 
     unsigned state_;
 };
diff --git a/libs/s25main/random/XorShift.h b/libs/s25main/random/XorShift.h
@@ -46,8 +46,8 @@ class XorShift
 private:
     friend std::ostream& operator<<(std::ostream& os, const XorShift& obj);
     friend std::istream& operator>>(std::istream& is, XorShift& obj);
-    friend bool operator==(const XorShift& lhs, const XorShift& rhs) { return lhs.state_ == rhs.state_; }
-    friend bool operator!=(const XorShift& lhs, const XorShift& rhs) { return !(lhs == rhs); }
+    friend bool operator==(const XorShift& lhs, const XorShift& rhs) noexcept { return lhs.state_ == rhs.state_; }
+    friend bool operator!=(const XorShift& lhs, const XorShift& rhs) noexcept { return !(lhs == rhs); }
 
     uint64_t state_; //-V730_NOINIT
 };
diff --git a/libs/s25main/resources/ResolvedFile.h b/libs/s25main/resources/ResolvedFile.h
@@ -24,9 +24,9 @@ class ResolvedFile : private std::vector<boost::filesystem::path>
     using Parent::end;
     using Parent::push_back;
     using Parent::size;
-    friend bool operator==(const ResolvedFile& lhs, const ResolvedFile& rhs)
+    friend bool operator==(const ResolvedFile& lhs, const ResolvedFile& rhs) noexcept
     {
         return static_cast<const Parent&>(lhs) == static_cast<const Parent&>(rhs);
     }
-    friend bool operator!=(const ResolvedFile& lhs, const ResolvedFile& rhs) { return !(lhs == rhs); }
+    friend bool operator!=(const ResolvedFile& lhs, const ResolvedFile& rhs) noexcept { return !(lhs == rhs); }
 };
diff --git a/libs/s25main/world/TerritoryRegion.h b/libs/s25main/world/TerritoryRegion.h
@@ -54,7 +54,7 @@ class TerritoryRegion
         /// Distance to next military bld
         uint16_t radius;
 
-        TRNode() : owner(0), radius(0) {}
+        TRNode() noexcept : owner(0), radius(0) {}
     };
 
     /// Check whether the point is part of the polygon
diff --git a/tests/s25Main/UI/testControls.cpp b/tests/s25Main/UI/testControls.cpp
@@ -136,7 +136,12 @@ BOOST_FIXTURE_TEST_CASE(EditShowsCorrectChars, uiHelper::Fixture)
 {
     using utfDecoder = boost::nowide::detail::utf::utf_traits<char>;
     // Use a 1 Byte and a 2 Byte UTF8 "char"
-    const std::array<std::string, 6> chars = {u8"a", u8"b", u8"c", u8"\u0424", u8"\u041A", u8"\u043b"};
+    const auto chars = []() {
+        std::vector<std::string> res;
+        for(const auto* s : {u8"a", u8"b", u8"c", u8"\u0424", u8"\u041A", u8"\u043b"})
+            res.push_back(reinterpret_cast<const char*>(s));
+        return res;
+    }();
     std::vector<char32_t> codepoints(chars.size() + 1);
     std::transform(chars.begin(), chars.end(), codepoints.begin(), [](const auto& c) {
         auto it = c.begin();
diff --git a/tests/s25Main/audio/LoadMockupAudio.h b/tests/s25Main/audio/LoadMockupAudio.h
@@ -29,7 +29,7 @@ struct LoadMockupAudio
     /// Return a callable to be used with MOCK_EXPECT(...).calls(...) that loads a sound of the given type
     auto makeDoLoad(driver::SoundType type)
     {
-        return [=](auto&&...) { return audioDriverMock->doLoad(type); };
+        return [this, type](auto&&...) { return this->audioDriverMock->doLoad(type); };
     };
     auto makeUnloadHandle(driver::SoundType type)
     {
diff --git a/tools/ci/add-apt-keys.sh b/tools/ci/add-apt-keys.sh
@@ -0,0 +1,47 @@
+#!/bin/bash
+#
+# Copyright 2023-2024 Alexander Grund
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+#      http://www.boost.org/LICENSE_1_0.txt)
+#
+# Add APT keys
+# - Each argument should be a key URL or a key ID (0x...)
+# - $NET_RETRY_COUNT is the amount of retries attempted
+
+set -eu
+
+if curl --retry-all-errors 2>&1 | grep -iq unknown; then
+    # --retry-all-errors not available
+    curl_extra_options=""
+else
+    curl_extra_options="--retry-all-errors"
+fi
+
+function do_add_key
+{
+    key_url=$1
+    # If a keyserver URL (e.g. http://keyserver.ubuntu.com/pks/lookup?op=get&search=0x1E9377A2BA9EF27F)
+    # use the hash as the filename,
+    # if it is an ID, e.g. 0x1E9377A2BA9EF27F, use it as the filename, and http://keyserver.ubuntu.com/pks/lookup as the URL
+    # else assume the URL contains a filename, e.g. https://apt.llvm.org/llvm-snapshot.gpg.key
+    if [[ "$key_url" =~ .*keyserver.*search=0x([A-F0-9]+) ]]; then
+        keyfilename="${BASH_REMATCH[1]}.key"
+    elif [[ $key_url =~ ^0x[A-F0-9]+$ ]]; then
+        keyfilename=${key_url#0x}.key
+        key_server="keyserver.boost.org"
+        key_url="https://$key_server/pks/lookup?op=get&search=$key_url"
+    else
+        keyfilename=$(basename -s .key "$key_url")
+    fi
+    echo -e "\tDownloading APT key from '$key_url' to '$keyfilename'"
+    if ! curl ${curl_extra_options} --connect-timeout 15 -sSL --retry "${NET_RETRY_COUNT:-5}" "$key_url" | sudo gpg --dearmor -o "/etc/apt/trusted.gpg.d/${keyfilename}"; then
+        echo "Failed downloading $keyfilename"
+        return 1
+    fi
+}
+
+for key_url in "$@"; do
+    [[ -n $key_url ]] || continue
+    do_add_key "$key_url"
+done
diff --git a/tools/ci/add-apt-repositories.sh b/tools/ci/add-apt-repositories.sh
@@ -0,0 +1,34 @@
+#!/bin/bash
+#
+# Copyright 2023 Sam Darwin
+# Copyright 2023-2024 Alexander Grund
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+#      http://www.boost.org/LICENSE_1_0.txt)
+#
+# Add APT keys, i.e. wrapper around add-apt-repository
+# - Each argument should be a repository name
+# - $NET_RETRY_COUNT is the amount of retries attempted
+
+set -eu
+
+function do_add_repository {
+    name=$1
+    echo -e "\tAdding repository $name"
+    for i in $(seq "${NET_RETRY_COUNT:-3}"); do
+        if [[ $i -ne 1 ]]; then
+            sleep 10
+            echo -e "\tRetrying"
+        fi
+        if sudo -E apt-add-repository -y "$name"; then
+            return 0
+        fi
+    done
+    echo "Failed adding $name"
+    return 1 # Failed
+}
+
+for repo_name in "$@"; do
+    [[ -n $repo_name ]] || continue
+    do_add_repository "$repo_name"
+done

Original file line number	Diff line number	Diff line change
`@@ -43,11 +43,11 @@ struct RectBase`
`43`	`43`	`void move(const position_type& offset);`
`44`	`44`	`static RectBase move(RectBase rect, const position_type& offset);`
`45`	`45`
`46`		`- constexpr bool operator==(const RectBase& rhs) const`
	`46`	`+ constexpr bool operator==(const RectBase& rhs) const noexcept`
`47`	`47`	`{`
`48`	`48`	`return left == rhs.left && top == rhs.top && right == rhs.right && bottom == rhs.bottom;`
`49`	`49`	`}`
`50`		`- constexpr bool operator!=(const RectBase& rhs) const { return !(*this == rhs); }`
	`50`	`+ constexpr bool operator!=(const RectBase& rhs) const noexcept { return !(*this == rhs); }`
`51`	`51`	`};`
`52`	`52`
`53`	`53`	`using Rect = RectBase<int>;`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ struct EnumArray`
`33`	`33`	`iterator end() noexcept { return elems + size(); }`
`34`	`34`	`constexpr const_iterator end() const noexcept { return elems + size(); }`
`35`	`35`
`36`		`- constexpr bool operator==(const EnumArray& rhs)`
	`36`	`+ constexpr bool operator==(const EnumArray& rhs) noexcept`
`37`	`37`	`{`
`38`	`38`	`for(unsigned i = 0; i < size(); ++i)`
`39`	`39`	`{`
Original file line number	Diff line number	Diff line change
`@@ -48,23 +48,23 @@ class OptionalEnum`
`48`	`48`	`constexpr void reset() noexcept { value_ = invalidValue; }`
`49`	`49`
`50`	`50`	`// Those comparisons can be simplified to comparing value_ due to the invalid value being a distinct value`
`51`		`- friend constexpr bool operator==(OptionalEnum lhs, OptionalEnum rhs) { return lhs.value_ == rhs.value_; }`
`52`		`- friend constexpr bool operator!=(OptionalEnum lhs, OptionalEnum rhs) { return lhs.value_ != rhs.value_; }`
	`51`	`+ friend constexpr bool operator==(OptionalEnum lhs, OptionalEnum rhs) noexcept { return lhs.value_ == rhs.value_; }`
	`52`	`+ friend constexpr bool operator!=(OptionalEnum lhs, OptionalEnum rhs) noexcept { return lhs.value_ != rhs.value_; }`
`53`	`53`	`// Technically not required as above operators would be used, but included for better debug performance and`
`54`	`54`	`// mirroring the standard`
`55`		`- friend constexpr bool operator==(OptionalEnum lhs, const T& rhs)`
	`55`	`+ friend constexpr bool operator==(OptionalEnum lhs, const T& rhs) noexcept`
`56`	`56`	`{`
`57`	`57`	`return lhs.value_ == static_cast<underlying_type>(rhs);`
`58`	`58`	`}`
`59`		`- friend constexpr bool operator!=(OptionalEnum lhs, const T& rhs)`
	`59`	`+ friend constexpr bool operator!=(OptionalEnum lhs, const T& rhs) noexcept`
`60`	`60`	`{`
`61`	`61`	`return lhs.value_ != static_cast<underlying_type>(rhs);`
`62`	`62`	`}`
`63`		`- friend constexpr bool operator==(const T& lhs, OptionalEnum rhs)`
	`63`	`+ friend constexpr bool operator==(const T& lhs, OptionalEnum rhs) noexcept`
`64`	`64`	`{`
`65`	`65`	`return static_cast<underlying_type>(lhs) == rhs.value_;`
`66`	`66`	`}`
`67`		`- friend constexpr bool operator!=(const T& lhs, OptionalEnum rhs)`
	`67`	`+ friend constexpr bool operator!=(const T& lhs, OptionalEnum rhs) noexcept`
`68`	`68`	`{`
`69`	`69`	`return static_cast<underlying_type>(lhs) != rhs.value_;`
`70`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,17 +24,17 @@ struct AsyncChecksum`
`24`	`24`
`25`	`25`	`static AsyncChecksum create(const Game& game);`
`26`	`26`
`27`		`- bool operator==(const AsyncChecksum& rhs) const;`
`28`		`- bool operator!=(const AsyncChecksum& rhs) const;`
	`27`	`+ bool operator==(const AsyncChecksum& rhs) const noexcept;`
	`28`	`+ bool operator!=(const AsyncChecksum& rhs) const noexcept;`
`29`	`29`	`};`
`30`	`30`
`31`		`-inline bool AsyncChecksum::operator==(const AsyncChecksum& rhs) const`
	`31`	`+inline bool AsyncChecksum::operator==(const AsyncChecksum& rhs) const noexcept`
`32`	`32`	`{`
`33`	`33`	`return randChecksum == rhs.randChecksum && objCt == rhs.objCt && objIdCt == rhs.objIdCt && eventCt == rhs.eventCt`
`34`	`34`	`&& evInstanceCt == rhs.evInstanceCt;`
`35`	`35`	`}`
`36`	`36`
`37`		`-inline bool AsyncChecksum::operator!=(const AsyncChecksum& rhs) const`
	`37`	`+inline bool AsyncChecksum::operator!=(const AsyncChecksum& rhs) const noexcept`
`38`	`38`	`{`
`39`	`39`	`return !(*this == rhs);`
`40`	`40`	`}`