From 5bae9c6457e6dd35ae5a992eb655ec7ffd80c5ae Mon Sep 17 00:00:00 2001
From: Teon Banek <teon.banek@memgraph.io>
Date: Thu, 8 Aug 2019 10:14:31 +0200
Subject: [PATCH] Move storage::Result to utils

Summary:
Utils now contain a BasicResult implementation which supports different
types of error. This will make it useful for other parts of the code as
well as during the transition from old to new storage.

Reviewers: mtomic, msantl, mferencevic

Reviewed By: mferencevic

Subscribers: pullbot

Differential Revision: https://phabricator.memgraph.io/D2291
---
 src/storage/v2/result.hpp | 77 +++----------------------------
 src/utils/result.hpp      | 96 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 102 insertions(+), 71 deletions(-)
 create mode 100644 src/utils/result.hpp

diff --git a/src/storage/v2/result.hpp b/src/storage/v2/result.hpp
index 4f9bee556..273680271 100644
--- a/src/storage/v2/result.hpp
+++ b/src/storage/v2/result.hpp
@@ -1,85 +1,20 @@
 #pragma once
 
-#include <optional>
+#include <type_traits>
 
-#include <glog/logging.h>
+#include "utils/result.hpp"
 
 namespace storage {
 
+static_assert(std::is_same_v<uint8_t, unsigned char>);
+
 enum class Error : uint8_t {
   SERIALIZATION_ERROR,
   DELETED_OBJECT,
   VERTEX_HAS_EDGES,
 };
 
-template <typename TValue>
-class [[nodiscard]] Result final {
- public:
-  explicit Result(const TValue &value) : value_(value) {}
-  explicit Result(TValue &&value) : value_(std::move(value)) {}
-  explicit Result(const Error &error) : error_(error) {}
-
-  bool HasValue() const { return value_.has_value(); }
-  bool HasError() const { return error_.has_value(); }
-
-  TValue &GetValue() & {
-    CHECK(value_) << "The storage result is an error!";
-    return *value_;
-  }
-
-  TValue &&GetValue() && {
-    CHECK(value_) << "The storage result is an error!";
-    return std::move(*value_);
-  }
-
-  const TValue &GetValue() const & {
-    CHECK(value_) << "The storage result is an error!";
-    return *value_;
-  }
-
-  const TValue &&GetValue() const && {
-    CHECK(value_) << "The storage result is an error!";
-    return std::move(*value_);
-  }
-
-  TValue &operator*() & {
-    CHECK(value_) << "The storage result is an error!";
-    return *value_;
-  }
-
-  TValue &&operator*() && {
-    CHECK(value_) << "The storage result is an error!";
-    return std::move(*value_);
-  }
-
-  const TValue &operator*() const & {
-    CHECK(value_) << "The storage result is an error!";
-    return *value_;
-  }
-
-  const TValue &&operator*() const && {
-    CHECK(value_) << "The storage result is an error!";
-    return std::move(*value_);
-  }
-
-  TValue *operator->() {
-    CHECK(value_) << "The storage result is an error!";
-    return &*value_;
-  }
-
-  const TValue *operator->() const {
-    CHECK(value_) << "The storage result is an error!";
-    return &*value_;
-  }
-
-  Error GetError() const {
-    CHECK(error_) << "The storage result is a value!";
-    return *error_;
-  }
-
- private:
-  std::optional<TValue> value_;
-  std::optional<Error> error_;
-};
+template <class TValue>
+using Result = utils::BasicResult<Error, TValue>;
 
 }  // namespace storage
diff --git a/src/utils/result.hpp b/src/utils/result.hpp
new file mode 100644
index 000000000..f4c11d33d
--- /dev/null
+++ b/src/utils/result.hpp
@@ -0,0 +1,96 @@
+/// @file
+#pragma once
+
+#include <optional>
+
+#include <glog/logging.h>
+
+namespace utils {
+
+template <class TError, class TValue>
+class [[nodiscard]] BasicResult final {
+ public:
+  explicit BasicResult(const TValue &value) : value_(value) {}
+  explicit BasicResult(TValue &&value) noexcept : value_(std::move(value)) {}
+  explicit BasicResult(const TError &error) : error_(error) {}
+  explicit BasicResult(TError &&error) noexcept : error_(std::move(error)) {}
+
+  bool HasValue() const { return value_.has_value(); }
+  bool HasError() const { return error_.has_value(); }
+
+  TValue &GetValue() & {
+    CHECK(value_) << "The storage result is an error!";
+    return *value_;
+  }
+
+  TValue &&GetValue() && {
+    CHECK(value_) << "The storage result is an error!";
+    return std::move(*value_);
+  }
+
+  const TValue &GetValue() const & {
+    CHECK(value_) << "The storage result is an error!";
+    return *value_;
+  }
+
+  const TValue &&GetValue() const && {
+    CHECK(value_) << "The storage result is an error!";
+    return std::move(*value_);
+  }
+
+  TValue &operator*() & {
+    CHECK(value_) << "The storage result is an error!";
+    return *value_;
+  }
+
+  TValue &&operator*() && {
+    CHECK(value_) << "The storage result is an error!";
+    return std::move(*value_);
+  }
+
+  const TValue &operator*() const & {
+    CHECK(value_) << "The storage result is an error!";
+    return *value_;
+  }
+
+  const TValue &&operator*() const && {
+    CHECK(value_) << "The storage result is an error!";
+    return std::move(*value_);
+  }
+
+  TValue *operator->() {
+    CHECK(value_) << "The storage result is an error!";
+    return &*value_;
+  }
+
+  const TValue *operator->() const {
+    CHECK(value_) << "The storage result is an error!";
+    return &*value_;
+  }
+
+  TError &GetError() & {
+    CHECK(error_) << "The storage result is a value!";
+    return *error_;
+  }
+
+  TError &&GetError() && {
+    CHECK(error_) << "The storage result is a value!";
+    return std::move(*error_);
+  }
+
+  const TError &GetError() const & {
+    CHECK(error_) << "The storage result is a value!";
+    return *error_;
+  }
+
+  const TError &&GetError() const && {
+    CHECK(error_) << "The storage result is a value!";
+    return std::move(*error_);
+  }
+
+ private:
+  std::optional<TValue> value_;
+  std::optional<TError> error_;
+};
+
+}  // namespace utils