1 files changed, 32 insertions, 35 deletions

diff --git a/src/buildtool/common/remote/remote_common.hpp b/src/buildtool/common/remote/remote_common.hpp
index 70c1b6cb..0f995dd5 100644
--- a/src/buildtool/common/remote/remote_common.hpp
+++ b/src/buildtool/common/remote/remote_common.hpp
@@ -20,12 +20,12 @@
 #include <sstream>
 #include <string>
 #include <utility>
-#include <variant>
 #include <vector>
 
 #include "fmt/core.h"
 #include "nlohmann/json.hpp"
 #include "src/buildtool/common/remote/port.hpp"
+#include "src/utils/cpp/expected.hpp"
 
 struct ServerAddress {
     std::string host{};
@@ -64,69 +64,66 @@ struct ServerAddress {
 }
 
 [[nodiscard]] static auto
-ParseDispatch(std::string const& dispatch_info) noexcept -> std::variant<
-    std::string,
-    std::vector<std::pair<std::map<std::string, std::string>, ServerAddress>>> {
-    using result_t =
-        std::variant<std::string,
-                     std::vector<std::pair<std::map<std::string, std::string>,
-                                           ServerAddress>>>;
+ParseDispatch(std::string const& dispatch_info) noexcept -> expected<
+    std::vector<std::pair<std::map<std::string, std::string>, ServerAddress>>,
+    std::string> {
     nlohmann::json dispatch;
     try {
         dispatch = nlohmann::json::parse(dispatch_info);
     } catch (std::exception const& e) {
-        return fmt::format("Failed to parse endpoint configuration: {}",
-                           e.what());
+        return unexpected{fmt::format(
+            "Failed to parse endpoint configuration: {}", e.what())};
     }
     std::vector<std::pair<std::map<std::string, std::string>, ServerAddress>>
         parsed{};
     try {
         if (not dispatch.is_array()) {
-            return fmt::format(
-                "Endpoint configuration has to be a "
-                "list of pairs, but found {}",
-                dispatch.dump());
+            return unexpected{
+                fmt::format("Endpoint configuration has to be a "
+                            "list of pairs, but found {}",
+                            dispatch.dump())};
         }
         for (auto const& entry : dispatch) {
             if (not(entry.is_array() and entry.size() == 2)) {
-                return fmt::format(
-                    "Endpoint configuration has to be a list of "
-                    "pairs, but found entry {}",
-                    entry.dump());
+                return unexpected{
+                    fmt::format("Endpoint configuration has to be a list of "
+                                "pairs, but found entry {}",
+                                entry.dump())};
             }
             if (not entry[0].is_object()) {
-                return fmt::format(
-                    "Property condition has to be "
-                    "given as an object, but found {}",
-                    entry[0].dump());
+                return unexpected{
+                    fmt::format("Property condition has to be "
+                                "given as an object, but found {}",
+                                entry[0].dump())};
             }
             std::map<std::string, std::string> props{};
             for (auto const& [k, v] : entry[0].items()) {
                 if (not v.is_string()) {
-                    return fmt::format(
-                        "Property condition has to be given as an "
-                        "object of strings but found {}",
-                        entry[0].dump());
+                    return unexpected{
+                        fmt::format("Property condition has to be given as an "
+                                    "object of strings but found {}",
+                                    entry[0].dump())};
                 }
                 props.emplace(k, v.template get<std::string>());
             }
             if (not entry[1].is_string()) {
-                return fmt::format(
-                    "Endpoint has to be specified as string (in "
-                    "the form host:port), but found {}",
-                    entry[1].dump());
+                return unexpected{
+                    fmt::format("Endpoint has to be specified as string (in "
+                                "the form host:port), but found {}",
+                                entry[1].dump())};
             }
             auto endpoint = ParseAddress(entry[1].template get<std::string>());
             if (not endpoint) {
-                return fmt::format("Failed to parse {} as endpoint.",
-                                   entry[1].dump());
+                return unexpected{fmt::format("Failed to parse {} as endpoint.",
+                                              entry[1].dump())};
             }
             parsed.emplace_back(props, *endpoint);
         }
     } catch (std::exception const& e) {
-        return fmt::format("Failure analysing endpoint configuration {}: {}",
-                           dispatch.dump(),
-                           e.what());
+        return unexpected{
+            fmt::format("Failure analysing endpoint configuration {}: {}",
+                        dispatch.dump(),
+                        e.what())};
     }
     // success!
     return parsed;