use var::variant and var::visit shims because apple is sux

llarp/handlers/tun.cpp

@@ -501,10 +501,7 @@ namespace llarp
           LookupNameAsync(lnsName, [msg, lnsName, reply](auto maybe) mutable {
             if (maybe.has_value())
             {
-              if (auto* addr = std::get_if<service::Address>(&*maybe))
-              {
-                msg.AddMXReply(addr->ToString(), 1);
-              }
+              var::visit([&](auto&& value) { msg.AddMXReply(value.ToString(), 1); }, *maybe);
             }
             else
             {

llarp/service/endpoint.cpp

@@ -802,7 +802,7 @@ namespace llarp
     void
     Endpoint::LookupNameAsync(
         std::string name,
-        std::function<void(std::optional<std::variant<Address, RouterID>>)> handler)
+        std::function<void(std::optional<var::variant<Address, RouterID>>)> handler)
     {
       auto& cache = m_state->nameCache;
       const auto maybe = cache.Get(name);
@@ -827,9 +827,16 @@ namespace llarp
       }
 
       auto maybeInvalidateCache = [handler, &cache, name](auto result) {
-        if (result and result->IsZero())
+        if (result)
         {
-          result = std::nullopt;
+          var::visit(
+              [&](auto&& value) {
+                if (value.IsZero())
+                {
+                  result = std::nullopt;
+                }
+              },
+              *result);
         }
         if (result)
         {

llarp/service/endpoint.hpp

@@ -21,7 +21,7 @@
 
 #include "auth.hpp"
 
-#include <variant>
+#include <oxenmq/variant.h>
 
 // minimum time between introset shifts
 #ifndef MIN_SHIFT_INTERVAL
@@ -223,7 +223,7 @@ namespace llarp
       void
       LookupNameAsync(
           std::string name,
-          std::function<void(std::optional<std::variant<Address, RouterID>>)> resultHandler);
+          std::function<void(std::optional<var::variant<Address, RouterID>>)> resultHandler);
 
       /// called on event loop pump
       virtual void

llarp/service/endpoint_state.hpp

@@ -65,7 +65,8 @@ namespace llarp
 
       OutboundSessions_t m_OutboundSessions;
 
-      util::DecayingHashTable<std::string, Address, std::hash<std::string>> nameCache;
+      util::DecayingHashTable<std::string, var::variant<Address, RouterID>, std::hash<std::string>>
+          nameCache;
 
       LNSLookupTracker lnsTracker;
 

llarp/service/lns_tracker.cpp

@@ -2,14 +2,14 @@
 
 namespace llarp::service
 {
-  std::function<void(std::optional<Address>)>
+  std::function<void(std::optional<LNSLookupTracker::Addr_t>)>
   LNSLookupTracker::MakeResultHandler(
       std::string name,
       std::size_t numPeers,
-      std::function<void(std::optional<Address>)> resultHandler)
+      std::function<void(std::optional<Addr_t>)> resultHandler)
   {
     m_PendingLookups.emplace(name, LookupInfo{numPeers, resultHandler});
-    return [name, this](std::optional<Address> found) {
+    return [name, this](std::optional<Addr_t> found) {
       auto itr = m_PendingLookups.find(name);
       if (itr == m_PendingLookups.end())
         return;
@@ -26,7 +26,7 @@ namespace llarp::service
   }
 
   void
-  LNSLookupTracker::LookupInfo::HandleOneResult(std::optional<Address> result)
+  LNSLookupTracker::LookupInfo::HandleOneResult(std::optional<Addr_t> result)
   {
     if (result)
     {

llarp/service/lns_tracker.hpp

@@ -7,20 +7,26 @@
 #include <string>
 
 #include "address.hpp"
+#include <llarp/router_id.hpp>
+#include <oxenmq/variant.h>
 
 namespace llarp::service
 {
   /// tracks and manages consensus of lns names we fetch from the network
   class LNSLookupTracker
   {
+   public:
+    using Addr_t = var::variant<Address, RouterID>;
+
+   private:
     struct LookupInfo
     {
-      std::unordered_set<Address> m_CurrentValues;
-      std::function<void(std::optional<Address>)> m_HandleResult;
+      std::unordered_set<Addr_t> m_CurrentValues;
+      std::function<void(std::optional<Addr_t>)> m_HandleResult;
       std::size_t m_ResultsGotten = 0;
       std::size_t m_ResultsNeeded;
 
-      LookupInfo(std::size_t wantResults, std::function<void(std::optional<Address>)> resultHandler)
+      LookupInfo(std::size_t wantResults, std::function<void(std::optional<Addr_t>)> resultHandler)
           : m_HandleResult{std::move(resultHandler)}, m_ResultsNeeded{wantResults}
       {}
 
@@ -28,7 +34,7 @@ namespace llarp::service
       IsDone() const;
 
       void
-      HandleOneResult(std::optional<Address> result);
+      HandleOneResult(std::optional<Addr_t> result);
     };
 
     std::unordered_map<std::string, LookupInfo> m_PendingLookups;
@@ -38,10 +44,10 @@ namespace llarp::service
     /// name is the name we are requesting
     /// numPeers is the number of peers we asked
     /// resultHandler is a function that we are wrapping that will handle the final result
-    std::function<void(std::optional<Address>)>
+    std::function<void(std::optional<Addr_t>)>
     MakeResultHandler(
         std::string name,
         std::size_t numPeers,
-        std::function<void(std::optional<Address>)> resultHandler);
+        std::function<void(std::optional<Addr_t>)> resultHandler);
   };
 }  // namespace llarp::service