Dep/Boost: Partial support for boost 1.74 - asio

Ref #25470

src/common/Asio/AsioHacksFwd.h

@@ -46,36 +46,6 @@ namespace boost
 
             typedef basic_endpoint<tcp> tcp_endpoint;
         }
-#if BOOST_VERSION >= 107000
-        class executor;
-
-        namespace ip
-        {
-            template <typename InternetProtocol, typename Executor>
-            class basic_resolver;
-
-            typedef basic_resolver<tcp, executor> tcp_resolver;
-        }
-#elif BOOST_VERSION >= 106600
-        namespace ip
-        {
-            template <typename InternetProtocol>
-            class basic_resolver;
-
-            typedef basic_resolver<tcp> tcp_resolver;
-        }
-#else
-        namespace ip
-        {
-            template <typename InternetProtocol>
-            class resolver_service;
-
-            template <typename InternetProtocol, typename ResolverService>
-            class basic_resolver;
-
-            typedef basic_resolver<tcp, resolver_service<tcp>> tcp_resolver;
-        }
-#endif
     }
 }
 
@@ -83,6 +53,9 @@ namespace Trinity
 {
     namespace Asio
     {
+        class DeadlineTimer;
+        class IoContext;
+        class Resolver;
         class Strand;
     }
 }

src/common/Asio/Resolver.h

@@ -18,36 +18,48 @@
 #ifndef Resolver_h__
 #define Resolver_h__
 
+#include "IoContext.h"
 #include "Optional.h"
 #include <boost/asio/ip/tcp.hpp>
 #include <string>
 
 namespace Trinity
 {
-    namespace Net
+    namespace Asio
     {
-        inline Optional<boost::asio::ip::tcp::endpoint> Resolve(boost::asio::ip::tcp::resolver& resolver, boost::asio::ip::tcp const& protocol,
-            std::string const& host, std::string const& service)
+        /**
+          Hack to make it possible to forward declare resolver (one of its template arguments is a typedef to something super long and using nested classes)
+        */
+        class Resolver
         {
-            boost::system::error_code ec;
+        public:
+            explicit Resolver(IoContext& ioContext) : _impl(ioContext) { }
+
+            Optional<boost::asio::ip::tcp::endpoint> Resolve(boost::asio::ip::tcp const& protocol, std::string const& host, std::string const& service)
+            {
+                boost::system::error_code ec;
 #if BOOST_VERSION >= 106600
-            boost::asio::ip::resolver_base::flags flagsResolver = boost::asio::ip::resolver_base::all_matching;
-            boost::asio::ip::tcp::resolver::results_type results = resolver.resolve(protocol, host, service, flagsResolver, ec);
-            if (results.begin() == results.end() || ec)
-                return {};
+                boost::asio::ip::resolver_base::flags flagsResolver = boost::asio::ip::resolver_base::all_matching;
+                boost::asio::ip::tcp::resolver::results_type results = _impl.resolve(protocol, host, service, flagsResolver, ec);
+                if (results.begin() == results.end() || ec)
+                    return {};
 
-            return results.begin()->endpoint();
+                return results.begin()->endpoint();
 #else
-            boost::asio::ip::resolver_query_base::flags flagsQuery = boost::asio::ip::tcp::resolver::query::all_matching;
-            boost::asio::ip::tcp::resolver::query query(std::move(protocol), std::move(host), std::move(service), flagsQuery);
-            boost::asio::ip::tcp::resolver::iterator itr = resolver.resolve(query, ec);
-            boost::asio::ip::tcp::resolver::iterator end;
-            if (itr == end || ec)
-                return {};
+                boost::asio::ip::resolver_query_base::flags flagsQuery = boost::asio::ip::tcp::resolver::query::all_matching;
+                boost::asio::ip::tcp::resolver::query query(std::move(protocol), std::move(host), std::move(service), flagsQuery);
+                boost::asio::ip::tcp::resolver::iterator itr = _impl.resolve(query, ec);
+                boost::asio::ip::tcp::resolver::iterator end;
+                if (itr == end || ec)
+                    return {};
 
-            return itr->endpoint();
+                return itr->endpoint();
 #endif
-        }
+            }
+
+        private:
+            boost::asio::ip::tcp::resolver _impl;
+        };
     }
 }
 

src/server/shared/Realm/RealmList.cpp

@@ -28,9 +28,7 @@ RealmList::RealmList() : _updateInterval(0)
 {
 }
 
-RealmList::~RealmList()
-{
-}
+RealmList::~RealmList() = default;
 
 RealmList* RealmList::Instance()
 {
@@ -43,7 +41,7 @@ void RealmList::Initialize(Trinity::Asio::IoContext& ioContext, uint32 updateInt
 {
     _updateInterval = updateInterval;
     _updateTimer = std::make_unique<Trinity::Asio::DeadlineTimer>(ioContext);
-    _resolver = std::make_unique<boost::asio::ip::tcp::resolver>(ioContext);
+    _resolver = std::make_unique<Trinity::Asio::Resolver>(ioContext);
 
     LoadBuildInfo();
     // Get the content of the realmlist table in the database
@@ -63,8 +61,7 @@ void RealmList::LoadBuildInfo()
         do
         {
             Field* fields = result->Fetch();
-            _builds.emplace_back();
-            RealmBuildInfo& build = _builds.back();
+            RealmBuildInfo& build = _builds.emplace_back();
             build.MajorVersion = fields[0].GetUInt32();
             build.MinorVersion = fields[1].GetUInt32();
             build.BugfixVersion = fields[2].GetUInt32();
@@ -141,21 +138,21 @@ void RealmList::UpdateRealms(boost::system::error_code const& error)
                 std::string localAddressString = fields[3].GetString();
                 std::string localSubmaskString = fields[4].GetString();
 
-                Optional<boost::asio::ip::tcp::endpoint> externalAddress = Trinity::Net::Resolve(*_resolver, boost::asio::ip::tcp::v4(), externalAddressString, "");
+                Optional<boost::asio::ip::tcp::endpoint> externalAddress = _resolver->Resolve(boost::asio::ip::tcp::v4(), externalAddressString, "");
                 if (!externalAddress)
                 {
                     TC_LOG_ERROR("server.authserver", "Could not resolve address %s for realm \"%s\" id %u", externalAddressString.c_str(), name.c_str(), realmId);
                     continue;
                 }
 
-                Optional<boost::asio::ip::tcp::endpoint> localAddress = Trinity::Net::Resolve(*_resolver, boost::asio::ip::tcp::v4(), localAddressString, "");
+                Optional<boost::asio::ip::tcp::endpoint> localAddress = _resolver->Resolve(boost::asio::ip::tcp::v4(), localAddressString, "");
                 if (!localAddress)
                 {
                     TC_LOG_ERROR("server.authserver", "Could not resolve localAddress %s for realm \"%s\" id %u", localAddressString.c_str(), name.c_str(), realmId);
                     continue;
                 }
 
-                Optional<boost::asio::ip::tcp::endpoint> localSubmask = Trinity::Net::Resolve(*_resolver, boost::asio::ip::tcp::v4(), localSubmaskString, "");
+                Optional<boost::asio::ip::tcp::endpoint> localSubmask = _resolver->Resolve(boost::asio::ip::tcp::v4(), localSubmaskString, "");
                 if (!localSubmask)
                 {
                     TC_LOG_ERROR("server.authserver", "Could not resolve localSubnetMask %s for realm \"%s\" id %u", localSubmaskString.c_str(), name.c_str(), realmId);

src/server/shared/Realm/RealmList.h

@@ -44,15 +44,6 @@ namespace boost
     }
 }
 
-namespace Trinity
-{
-    namespace Asio
-    {
-        class IoContext;
-        class DeadlineTimer;
-    }
-}
-
 /// Storage object for the list of realms on the server
 class TC_SHARED_API RealmList
 {
@@ -84,7 +75,7 @@ private:
     RealmMap _realms;
     uint32 _updateInterval;
     std::unique_ptr<Trinity::Asio::DeadlineTimer> _updateTimer;
-    std::unique_ptr<boost::asio::ip::tcp_resolver> _resolver;
+    std::unique_ptr<Trinity::Asio::Resolver> _resolver;
 };
 
 #define sRealmList RealmList::Instance()

src/server/worldserver/Main.cpp

@@ -517,11 +517,11 @@ bool LoadRealmInfo(Trinity::Asio::IoContext& ioContext)
     if (!result)
         return false;
 
-    boost::asio::ip::tcp::resolver resolver(ioContext);
+    Trinity::Asio::Resolver resolver(ioContext);
 
     Field* fields = result->Fetch();
     realm.Name = fields[1].GetString();
-    Optional<boost::asio::ip::tcp::endpoint> externalAddress = Trinity::Net::Resolve(resolver, boost::asio::ip::tcp::v4(), fields[2].GetString(), "");
+    Optional<boost::asio::ip::tcp::endpoint> externalAddress = resolver.Resolve(boost::asio::ip::tcp::v4(), fields[2].GetString(), "");
     if (!externalAddress)
     {
         TC_LOG_ERROR("server.worldserver", "Could not resolve address %s", fields[2].GetString().c_str());
@@ -530,7 +530,7 @@ bool LoadRealmInfo(Trinity::Asio::IoContext& ioContext)
 
     realm.ExternalAddress = std::make_unique<boost::asio::ip::address>(externalAddress->address());
 
-    Optional<boost::asio::ip::tcp::endpoint> localAddress = Trinity::Net::Resolve(resolver, boost::asio::ip::tcp::v4(), fields[3].GetString(), "");
+    Optional<boost::asio::ip::tcp::endpoint> localAddress = resolver.Resolve(boost::asio::ip::tcp::v4(), fields[3].GetString(), "");
     if (!localAddress)
     {
         TC_LOG_ERROR("server.worldserver", "Could not resolve address %s", fields[3].GetString().c_str());
@@ -539,7 +539,7 @@ bool LoadRealmInfo(Trinity::Asio::IoContext& ioContext)
 
     realm.LocalAddress = std::make_unique<boost::asio::ip::address>(localAddress->address());
 
-    Optional<boost::asio::ip::tcp::endpoint> localSubmask = Trinity::Net::Resolve(resolver, boost::asio::ip::tcp::v4(), fields[4].GetString(), "");
+    Optional<boost::asio::ip::tcp::endpoint> localSubmask = resolver.Resolve(boost::asio::ip::tcp::v4(), fields[4].GetString(), "");
     if (!localSubmask)
     {
         TC_LOG_ERROR("server.worldserver", "Could not resolve address %s", fields[4].GetString().c_str());