refactoring

Co-authored-by: n.fedorov <mail@nfedorov.dev>
Co-committed-by: n.fedorov <mail@nfedorov.dev>

include/nxst/domain/result.hpp

@@ -0,0 +1,108 @@
+#pragma once
+#include <string>
+#include <utility>
+
+namespace nxst {
+
+    template <class T, class E = std::string> class Result {
+        bool ok;
+        alignas(T) alignas(E) unsigned char storage[sizeof(T) > sizeof(E) ? sizeof(T) : sizeof(E)];
+
+        Result() = default;
+
+      public:
+        static Result success(T val) {
+            Result res;
+            res.ok = true;
+            new (res.storage) T(std::move(val));
+            return res;
+        }
+
+        static Result failure(E err) {
+            Result res;
+            res.ok = false;
+            new (res.storage) E(std::move(err));
+            return res;
+        }
+
+        ~Result() {
+            if (ok)
+                reinterpret_cast<T*>(storage)->~T();
+            else
+                reinterpret_cast<E*>(storage)->~E();
+        }
+
+        Result(const Result& other) : ok(other.ok) {
+            if (ok)
+                new (storage) T(*reinterpret_cast<const T*>(other.storage));
+            else
+                new (storage) E(*reinterpret_cast<const E*>(other.storage));
+        }
+
+        Result(Result&& other) : ok(other.ok) {
+            if (ok)
+                new (storage) T(std::move(*reinterpret_cast<T*>(other.storage)));
+            else
+                new (storage) E(std::move(*reinterpret_cast<E*>(other.storage)));
+        }
+
+        Result& operator=(const Result&) = delete;
+
+        bool isOk() const noexcept {
+            return ok;
+        }
+        const T& value() const {
+            return *reinterpret_cast<const T*>(storage);
+        }
+        const E& error() const {
+            return *reinterpret_cast<const E*>(storage);
+        }
+    };
+
+    // Specialisation for Result<void>
+    template <class E> class Result<void, E> {
+        bool ok;
+        alignas(E) unsigned char storage[sizeof(E)];
+
+        Result() = default;
+
+      public:
+        static Result success() {
+            Result res;
+            res.ok = true;
+            return res;
+        }
+
+        static Result failure(E err) {
+            Result res;
+            res.ok = false;
+            new (res.storage) E(std::move(err));
+            return res;
+        }
+
+        ~Result() {
+            if (!ok)
+                reinterpret_cast<E*>(storage)->~E();
+        }
+
+        Result(const Result& other) : ok(other.ok) {
+            if (!ok)
+                new (storage) E(*reinterpret_cast<const E*>(other.storage));
+        }
+
+        Result(Result&& other) : ok(other.ok) {
+            if (!ok)
+                new (storage) E(std::move(*reinterpret_cast<E*>(other.storage)));
+        }
+
+        Result& operator=(const Result&) = delete;
+
+        bool isOk() const noexcept {
+            return ok;
+        }
+        const E& error() const {
+            return *reinterpret_cast<const E*>(storage);
+        }
+    };
+
+}  // namespace nxst