Use helpers::sort consistently

Flamefire · Flow86 · commit 58cb9475f742 · 2026-04-08T20:24:14.000+02:00
diff --git a/libs/common/include/helpers/containerUtils.h b/libs/common/include/helpers/containerUtils.h
@@ -132,6 +132,8 @@ size_t count_if(const T& container, T_Predicate&& predicate)
 template<class T, class T_Predicate = std::less<>>
 void sort(T& container, T_Predicate&& predicate = T_Predicate{})
 {
+    using std::begin;
+    using std::end;
     std::sort(begin(container), end(container), std::forward<T_Predicate>(predicate));
 }
 
diff --git a/libs/libGamedata/lua/CheckedLuaTable.cpp b/libs/libGamedata/lua/CheckedLuaTable.cpp
@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "CheckedLuaTable.h"
+#include "helpers/containerUtils.h"
 #include "s25util/Log.h"
 #include <boost/algorithm/string/join.hpp>
 #include <algorithm>
@@ -22,7 +23,7 @@ void CheckedLuaTable::checkUnused()
     checkEnabled = false;
 
     std::vector<std::string> tableKeys = table.keys<std::string>();
-    std::sort(tableKeys.begin(), tableKeys.end());
+    helpers::sort(tableKeys);
     std::vector<std::string> unusedKeys;
     std::set_difference(tableKeys.begin(), tableKeys.end(), accessedKeys_.begin(), accessedKeys_.end(),
                         std::back_inserter(unusedKeys));
diff --git a/libs/s25main/GamePlayer.cpp b/libs/s25main/GamePlayer.cpp
@@ -1022,7 +1022,7 @@ struct ClientForWare
         : bld(bld), estimate(estimate), points(points)
     {}
 
-    bool operator<(const ClientForWare& b) const
+    bool operator<(const ClientForWare& b) const noexcept
     {
         // use estimate, points and object id (as tie breaker) for sorting
         if(estimate != b.estimate)
@@ -1118,7 +1118,7 @@ noBaseBuilding* GamePlayer::FindClientForWare(const Ware& ware)
     }
 
     // sort our clients, highest score first
-    std::sort(possibleClients.begin(), possibleClients.end());
+    helpers::sort(possibleClients);
 
     noBaseBuilding* lastBld = nullptr;
     noBaseBuilding* bestBld = nullptr;
@@ -1903,7 +1903,7 @@ struct ShipForHarbor
 
     ShipForHarbor(noShip* ship, uint32_t estimate) : ship(ship), estimate(estimate) {}
 
-    bool operator<(const ShipForHarbor& b) const
+    bool operator<(const ShipForHarbor& b) const noexcept
     {
         return (estimate < b.estimate) || (estimate == b.estimate && ship->GetObjId() < b.ship->GetObjId());
     }
@@ -1934,7 +1934,7 @@ bool GamePlayer::OrderShip(nobHarborBuilding& hb)
         }
     }
 
-    std::sort(sfh.begin(), sfh.end());
+    helpers::sort(sfh);
 
     noShip* best_ship = nullptr;
     uint32_t best_distance = std::numeric_limits<uint32_t>::max();
@@ -2313,7 +2313,7 @@ void GamePlayer::Trade(nobBaseWarehouse* goalWh, const boost_variant2<GoodType,
     const MapPoint goalFlagPos = goalWh->GetFlagPos();
 
     std::vector<nobBaseWarehouse*> whs(buildings.GetStorehouses().begin(), buildings.GetStorehouses().end());
-    std::sort(whs.begin(), whs.end(), WarehouseDistanceComparator(*goalWh, world));
+    helpers::sort(whs, WarehouseDistanceComparator(*goalWh, world));
     TradePathCache& tradePathCache = world.GetTradePathCache();
     for(nobBaseWarehouse* wh : whs)
     {
diff --git a/libs/s25main/ListDir.cpp b/libs/s25main/ListDir.cpp
@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "ListDir.h"
+#include "helpers/containerUtils.h"
 #include "s25util/strAlgos.h"
 #include <boost/filesystem.hpp>
 #include <algorithm>
@@ -41,6 +42,6 @@ std::vector<bfs::path> ListDir(const bfs::path& path, std::string extension, boo
         result.emplace_back(std::move(curPath));
     }
 
-    std::sort(result.begin(), result.end());
+    helpers::sort(result);
     return result;
 }
diff --git a/libs/s25main/buildings/nobBaseMilitary.h b/libs/s25main/buildings/nobBaseMilitary.h
@@ -56,7 +56,7 @@ class nobBaseMilitary : public noBuilding
     const nofDefender* GetDefender() const { return defender_; }
 
     /// Compares according to build time (Age): Bigger objIds are "younger"
-    bool operator<(const nobBaseMilitary& other) const { return GetObjId() > other.GetObjId(); }
+    bool operator<(const nobBaseMilitary& other) const noexcept { return GetObjId() > other.GetObjId(); }
 
     /// Meldet ein neues "Rausgeh"-Event an, falls gerade keiner rausgeht
     /// (damit nicht alle auf einmal rauskommen), für Lager- und Militärhäuser)
diff --git a/libs/s25main/controls/ctrlTable.cpp b/libs/s25main/controls/ctrlTable.cpp
@@ -8,6 +8,7 @@
 #include "ctrlScrollBar.h"
 #include "driver/KeyEvent.h"
 #include "driver/MouseCoords.h"
+#include "helpers/containerUtils.h"
 #include "helpers/mathFuncs.h"
 #include "ogl/glFont.h"
 #include "s25util/StringConversion.h"
@@ -295,7 +296,7 @@ void ctrlTable::SortRows(unsigned column, const TableSortDir sortDir)
         const int cmpResult = Compare(a, b, sortType);
         return (sortDir == TableSortDir::Ascending) ? cmpResult < 0 : cmpResult > 0;
     };
-    std::sort(rows_.begin(), rows_.end(), compareFunc);
+    helpers::sort(rows_, compareFunc);
 }
 
 /**
diff --git a/libs/s25main/desktops/dskOptions.cpp b/libs/s25main/desktops/dskOptions.cpp
@@ -743,7 +743,7 @@ void dskOptions::loadVideoModes()
     // Remove everything below 800x600
     helpers::erase_if(video_modes, [](const auto& it) { return it.width < 800 && it.height < 600; });
     // Sort by aspect ratio
-    std::sort(video_modes.begin(), video_modes.end(), cmpVideoModes);
+    helpers::sort(video_modes, cmpVideoModes);
 }
 
 void dskOptions::Msg_ScreenResize(const ScreenResizeEvent& sr)
diff --git a/libs/s25main/gameTypes/HarborPos.h b/libs/s25main/gameTypes/HarborPos.h
@@ -19,7 +19,7 @@ struct HarborPos
 
         Neighbor(HarborId id, unsigned distance) noexcept : id(id), distance(distance) {}
 
-        bool operator<(const Neighbor& two) const
+        bool operator<(const Neighbor& two) const noexcept
         {
             return (distance < two.distance) || (distance == two.distance && id.value() < two.id.value());
         }
diff --git a/libs/s25main/languages.cpp b/libs/s25main/languages.cpp
@@ -12,7 +12,7 @@
 #include "libsiedler2/ArchivItem_Text.h"
 #include <algorithm>
 
-static bool operator<(const Language& o1, const Language& o2)
+static bool operator<(const Language& o1, const Language& o2) noexcept
 {
     if(o1.name < o2.name)
         return true;
@@ -45,7 +45,7 @@ void Languages::loadLanguages()
     }
 
     // Sprachen sortieren
-    std::sort(languages.begin(), languages.end());
+    helpers::sort(languages);
 
     // Systemsprache hinzufügen
     Language l(gettext_noop("System language"), "");
diff --git a/libs/s25main/mapGenerator/HeadQuarters.h b/libs/s25main/mapGenerator/HeadQuarters.h
@@ -66,7 +66,7 @@ std::vector<MapPoint> FindHqPositions(const Map& map, const T_Container& area, M
     const auto byDistanceToOtherHqs = [&distanceToOtherHqs](MapPoint p1, MapPoint p2) {
         return distanceToOtherHqs[p1] > distanceToOtherHqs[p2];
     };
-    std::sort(possiblePositions.begin(), possiblePositions.end(), byDistanceToOtherHqs);
+    helpers::sort(possiblePositions, byDistanceToOtherHqs);
 
     // 3. filter out points within minimum distance to existing HQs
     const unsigned minHqDistance = (map.size.x + map.size.y) / 16;
diff --git a/libs/s25main/mapGenerator/Textures.h b/libs/s25main/mapGenerator/Textures.h
@@ -71,7 +71,7 @@ class TextureOperator
             return sortBy(worldDesc_.get(t1)) < sortBy(worldDesc_.get(t2));
         };
 
-        std::sort(textures.begin(), textures.end(), lessThan);
+        helpers::sort(textures, lessThan);
     }
 
     template<class T_Predicate>
diff --git a/libs/s25main/network/GameServer.cpp b/libs/s25main/network/GameServer.cpp
@@ -476,7 +476,7 @@ bool GameServer::assignPlayersOfRandomTeams(std::vector<JoinPlayerInfo>& playerI
     }
 
     // To make the teams as even as possible we start to assign the most constrained players first
-    std::sort(playersToAssign.begin(), playersToAssign.end(), [](const AssignPlayer& lhs, const AssignPlayer& rhs) {
+    helpers::sort(playersToAssign, [](const AssignPlayer& lhs, const AssignPlayer& rhs) {
         return lhs.possibleTeams.size() < rhs.possibleTeams.size();
     });
 
diff --git a/libs/s25main/ogl/glTexturePacker.cpp b/libs/s25main/ogl/glTexturePacker.cpp
@@ -4,6 +4,7 @@
 
 #include "glTexturePacker.h"
 #include "drivers/VideoDriverWrapper.h"
+#include "helpers/containerUtils.h"
 #include "ogl/glSmartBitmap.h"
 #include "ogl/glTexturePackerNode.h"
 #include "ogl/saveBitmap.h"
@@ -117,7 +118,7 @@ bool glTexturePacker::packHelper(std::vector<glSmartBitmap*>& list)
 
 bool glTexturePacker::pack()
 {
-    std::sort(items.begin(), items.end(), isSizeGreater);
+    helpers::sort(items, isSizeGreater);
 
     if(packHelper(items))
         return true;
diff --git a/libs/s25main/pathfinding/PathfindingPoint.h b/libs/s25main/pathfinding/PathfindingPoint.h
@@ -17,7 +17,7 @@ struct PathfindingPoint
     {}
 
     /// Operator für den Vergleich
-    bool operator<(const PathfindingPoint& rhs) const
+    bool operator<(const PathfindingPoint& rhs) const noexcept
     {
         // Wenn die Wegkosten gleich sind, vergleichen wir die Koordinaten, da wir für std::set eine streng monoton
         // steigende Folge brauchen
diff --git a/libs/s25main/world/GameWorld.cpp b/libs/s25main/world/GameWorld.cpp
@@ -842,9 +842,9 @@ void GameWorld::AttackViaSea(const unsigned char player_attacker, const MapPoint
 
     // Sort them
     if(strong_soldiers)
-        std::sort(attackers.begin(), attackers.end(), CmpSeaAttacker<std::greater<>>());
+        helpers::sort(attackers, CmpSeaAttacker<std::greater<>>());
     else
-        std::sort(attackers.begin(), attackers.end(), CmpSeaAttacker<std::less<>>());
+        helpers::sort(attackers, CmpSeaAttacker<std::less<>>());
 
     auto& attacked_building = *GetSpecObj<nobBaseMilitary>(pt);
     unsigned counter = 0;
diff --git a/tests/s25Main/integration/testWorld.cpp b/tests/s25Main/integration/testWorld.cpp
@@ -155,15 +155,15 @@ BOOST_AUTO_TEST_CASE(HQPlacement)
     BOOST_TEST(hqsOriginalMap.size() == numPlayers);
     BOOST_TEST(hqsShuffledMap.size() == numPlayers);
     // The loader stores the HQ positions read from the map
-    BOOST_TEST(hqsShuffledMap == hqsOriginalMap);
+    BOOST_TEST(hqsShuffledMap == hqsOriginalMap, boost::test_tools::per_element());
     // When shuffled the positions should have changed
-    BOOST_TEST(hqsShuffledWorld != hqsOriginalWorld);
+    BOOST_TEST(hqsShuffledWorld != hqsOriginalWorld, boost::test_tools::per_element());
     helpers::sort(hqsOriginalMap, MapPointLess{});
     helpers::sort(hqsShuffledWorld, MapPointLess{});
     helpers::sort(hqsOriginalWorld, MapPointLess{});
     // But the same positions should be used just in different order
-    BOOST_TEST(hqsOriginalMap == hqsOriginalWorld);
-    BOOST_TEST(hqsShuffledWorld == hqsOriginalWorld);
+    BOOST_TEST(hqsOriginalMap == hqsOriginalWorld, boost::test_tools::per_element());
+    BOOST_TEST(hqsShuffledWorld == hqsOriginalWorld, boost::test_tools::per_element());
 }
 
 BOOST_FIXTURE_TEST_CASE(CloseHarborSpots, WorldFixture<UninitializedWorldCreator>)
diff --git a/tests/s25Main/lua/testLua.cpp b/tests/s25Main/lua/testLua.cpp
@@ -819,8 +819,8 @@ BOOST_AUTO_TEST_CASE(onOccupied)
     {
         Points& gamePts = gamePtsPerPlayer[i];
         Points& luaPts = luaPtsPerPlayer[i];
-        std::sort(gamePts.begin(), gamePts.end());
-        std::sort(luaPts.begin(), luaPts.end());
+        helpers::sort(gamePts);
+        helpers::sort(luaPts);
         BOOST_TEST_REQUIRE(luaPts == gamePts, boost::test_tools::per_element());
     }
 }
@@ -851,8 +851,8 @@ BOOST_AUTO_TEST_CASE(onExplored)
     {
         Points& gamePts = gamePtsPerPlayer[i];
         Points& luaPts = luaPtsPerPlayer[i];
-        std::sort(gamePts.begin(), gamePts.end());
-        std::sort(luaPts.begin(), luaPts.end());
+        helpers::sort(gamePts);
+        helpers::sort(luaPts);
         BOOST_TEST_REQUIRE(luaPts == gamePts, boost::test_tools::per_element());
     }
 }
diff --git a/tests/s25Main/simple/testMapBase.cpp b/tests/s25Main/simple/testMapBase.cpp
@@ -5,6 +5,7 @@
 #include "PointOutput.h"
 #include "enum_cast.hpp"
 #include "helpers/EnumArray.h"
+#include "helpers/containerUtils.h"
 #include "world/MapBase.h"
 #include "world/MapGeometry.h"
 #include "gameData/MapConsts.h"
@@ -39,8 +40,8 @@ BOOST_AUTO_TEST_CASE(GetAllNeighboursUnion)
 
     auto resultPoints = world.GetAllNeighboursUnion(testPoints);
 
-    std::sort(resultPoints.begin(), resultPoints.end(), MapPointLess());
-    std::sort(expectedResultPoints.begin(), expectedResultPoints.end(), MapPointLess());
+    helpers::sort(resultPoints, MapPointLess());
+    helpers::sort(expectedResultPoints, MapPointLess());
 
     BOOST_TEST(resultPoints == expectedResultPoints, boost::test_tools::per_element());
 }

Original file line number	Diff line number	Diff line change
`@@ -132,6 +132,8 @@ size_t count_if(const T& container, T_Predicate&& predicate)`
`132`	`132`	`template<class T, class T_Predicate = std::less<>>`
`133`	`133`	`void sort(T& container, T_Predicate&& predicate = T_Predicate{})`
`134`	`134`	`{`
	`135`	`+ using std::begin;`
	`136`	`+ using std::end;`
`135`	`137`	`std::sort(begin(container), end(container), std::forward<T_Predicate>(predicate));`
`136`	`138`	`}`
`137`	`139`
Original file line number	Diff line number	Diff line change
`@@ -1022,7 +1022,7 @@ struct ClientForWare`
`1022`	`1022`	`: bld(bld), estimate(estimate), points(points)`
`1023`	`1023`	`{}`
`1024`	`1024`
`1025`		`- bool operator<(const ClientForWare& b) const`
	`1025`	`+ bool operator<(const ClientForWare& b) const noexcept`
`1026`	`1026`	`{`
`1027`	`1027`	`// use estimate, points and object id (as tie breaker) for sorting`
`1028`	`1028`	`if(estimate != b.estimate)`
`@@ -1118,7 +1118,7 @@ noBaseBuilding* GamePlayer::FindClientForWare(const Ware& ware)`
`1118`	`1118`	`}`
`1119`	`1119`
`1120`	`1120`	`// sort our clients, highest score first`
`1121`		`- std::sort(possibleClients.begin(), possibleClients.end());`
	`1121`	`+ helpers::sort(possibleClients);`
`1122`	`1122`
`1123`	`1123`	`noBaseBuilding* lastBld = nullptr;`
`1124`	`1124`	`noBaseBuilding* bestBld = nullptr;`
`@@ -1903,7 +1903,7 @@ struct ShipForHarbor`
`1903`	`1903`
`1904`	`1904`	`ShipForHarbor(noShip* ship, uint32_t estimate) : ship(ship), estimate(estimate) {}`
`1905`	`1905`
`1906`		`- bool operator<(const ShipForHarbor& b) const`
	`1906`	`+ bool operator<(const ShipForHarbor& b) const noexcept`
`1907`	`1907`	`{`
`1908`	`1908`	`return (estimate < b.estimate) \|\| (estimate == b.estimate && ship->GetObjId() < b.ship->GetObjId());`
`1909`	`1909`	`}`
`@@ -1934,7 +1934,7 @@ bool GamePlayer::OrderShip(nobHarborBuilding& hb)`
`1934`	`1934`	`}`
`1935`	`1935`	`}`
`1936`	`1936`
`1937`		`- std::sort(sfh.begin(), sfh.end());`
	`1937`	`+ helpers::sort(sfh);`
`1938`	`1938`
`1939`	`1939`	`noShip* best_ship = nullptr;`
`1940`	`1940`	`uint32_t best_distance = std::numeric_limits<uint32_t>::max();`
`@@ -2313,7 +2313,7 @@ void GamePlayer::Trade(nobBaseWarehouse* goalWh, const boost_variant2<GoodType,`
`2313`	`2313`	`const MapPoint goalFlagPos = goalWh->GetFlagPos();`
`2314`	`2314`
`2315`	`2315`	`std::vector<nobBaseWarehouse*> whs(buildings.GetStorehouses().begin(), buildings.GetStorehouses().end());`
`2316`		`- std::sort(whs.begin(), whs.end(), WarehouseDistanceComparator(*goalWh, world));`
	`2316`	`+ helpers::sort(whs, WarehouseDistanceComparator(*goalWh, world));`
`2317`	`2317`	`TradePathCache& tradePathCache = world.GetTradePathCache();`
`2318`	`2318`	`for(nobBaseWarehouse* wh : whs)`
`2319`	`2319`	`{`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`// SPDX-License-Identifier: GPL-2.0-or-later`
`4`	`4`
`5`	`5`	`#include "ListDir.h"`
	`6`	`+#include "helpers/containerUtils.h"`
`6`	`7`	`#include "s25util/strAlgos.h"`
`7`	`8`	`#include <boost/filesystem.hpp>`
`8`	`9`	`#include <algorithm>`
`@@ -41,6 +42,6 @@ std::vector<bfs::path> ListDir(const bfs::path& path, std::string extension, boo`
`41`	`42`	`result.emplace_back(std::move(curPath));`
`42`	`43`	`}`
`43`	`44`
`44`		`- std::sort(result.begin(), result.end());`
	`45`	`+ helpers::sort(result);`
`45`	`46`	`return result;`
`46`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -743,7 +743,7 @@ void dskOptions::loadVideoModes()`
`743`	`743`	`// Remove everything below 800x600`
`744`	`744`	`helpers::erase_if(video_modes, [](const auto& it) { return it.width < 800 && it.height < 600; });`
`745`	`745`	`// Sort by aspect ratio`
`746`		`- std::sort(video_modes.begin(), video_modes.end(), cmpVideoModes);`
	`746`	`+ helpers::sort(video_modes, cmpVideoModes);`
`747`	`747`	`}`
`748`	`748`
`749`	`749`	`void dskOptions::Msg_ScreenResize(const ScreenResizeEvent& sr)`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ struct HarborPos`
`19`	`19`
`20`	`20`	`Neighbor(HarborId id, unsigned distance) noexcept : id(id), distance(distance) {}`
`21`	`21`
`22`		`- bool operator<(const Neighbor& two) const`
	`22`	`+ bool operator<(const Neighbor& two) const noexcept`
`23`	`23`	`{`
`24`	`24`	`return (distance < two.distance) \|\| (distance == two.distance && id.value() < two.id.value());`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@`
`12`	`12`	`#include "libsiedler2/ArchivItem_Text.h"`
`13`	`13`	`#include <algorithm>`
`14`	`14`
`15`		`-static bool operator<(const Language& o1, const Language& o2)`
	`15`	`+static bool operator<(const Language& o1, const Language& o2) noexcept`
`16`	`16`	`{`
`17`	`17`	`if(o1.name < o2.name)`
`18`	`18`	`return true;`
`@@ -45,7 +45,7 @@ void Languages::loadLanguages()`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`// Sprachen sortieren`
`48`		`- std::sort(languages.begin(), languages.end());`
	`48`	`+ helpers::sort(languages);`
`49`	`49`
`50`	`50`	`// Systemsprache hinzufügen`
`51`	`51`	`Language l(gettext_noop("System language"), "");`