Refactor storage interface

core/common/buffer_or_view.hpp

@@ -0,0 +1,74 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef KAGOME_COMMON_BUFFER_OR_VIEW_HPP
+#define KAGOME_COMMON_BUFFER_OR_VIEW_HPP
+
+#include <variant>
+
+#include "common/buffer.hpp"
+
+namespace kagome::common {
+  class BufferOrView {
+   public:
+    BufferOrView() = default;
+
+    BufferOrView(const BufferView &view) : variant{view} {}
+
+    BufferOrView(const std::vector<uint8_t> &vector) = delete;
+    BufferOrView(std::vector<uint8_t> &&vector)
+        : variant{Buffer{std::move(vector)}} {}
+
+    BufferOrView(const BufferOrView &) = delete;
+    BufferOrView(BufferOrView &&) = default;
+
+    BufferOrView &operator=(const BufferOrView &) = delete;
+    BufferOrView &operator=(BufferOrView &&) = default;
+
+    bool owned() const {
+      return variant.index() == 1;
+    }
+
+    BufferView view() const {
+      if (!owned()) {
+        return std::get<BufferView>(variant);
+      }
+      return BufferView{std::get<Buffer>(variant)};
+    }
+
+    operator BufferView() const {
+      return view();
+    }
+
+    size_t size() const {
+      return view().size();
+    }
+
+    // get mutable buffer reference, copy once if view
+    Buffer &mut() {
+      if (!owned()) {
+        auto view = std::get<BufferView>(variant);
+        variant.emplace<Buffer>(view);
+      }
+      return std::get<Buffer>(variant);
+    }
+
+    // move buffer away, copy once if view
+    Buffer into() {
+      auto buffer = std::move(mut());
+      variant.emplace<BufferView>();
+      return buffer;
+    }
+
+   private:
+    std::variant<BufferView, Buffer> variant;
+  };
+}  // namespace kagome::common
+
+template <>
+struct fmt::formatter<kagome::common::BufferOrView>
+    : fmt::formatter<kagome::common::BufferView> {};
+
+#endif  // KAGOME_COMMON_BUFFER_OR_VIEW_HPP

core/storage/buffer_map_types.hpp

@@ -12,15 +12,24 @@
  */
 
 #include "common/buffer.hpp"
+#include "common/buffer_or_view.hpp"
 #include "storage/face/batch_writeable.hpp"
 #include "storage/face/generic_maps.hpp"
 #include "storage/face/write_batch.hpp"
 
+namespace kagome::storage::face {
+  template <>
+  struct OwnedOrView<common::Buffer> {
+    using type = common::BufferOrView;
+  };
+}  // namespace kagome::storage::face
+
 namespace kagome::storage {
 
   using Buffer = common::SLBuffer<std::numeric_limits<size_t>::max()>;
   using BufferView = common::BufferView;
   using BufferConstRef = common::BufferConstRef;
+  using common::BufferOrView;
 
   using BufferBatch = face::WriteBatch<BufferView, Buffer>;
 

core/storage/face/owned_or_view.hpp

@@ -0,0 +1,17 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef KAGOME_STORAGE_FACE_OWNED_OR_VIEW_HPP
+#define KAGOME_STORAGE_FACE_OWNED_OR_VIEW_HPP
+
+namespace kagome::storage::face {
+  template <typename T>
+  struct OwnedOrView;
+
+  template <typename T>
+  using OwnedOrViewOf = typename OwnedOrView<T>::type;
+}  // namespace kagome::storage::face
+
+#endif  // KAGOME_STORAGE_FACE_OWNED_OR_VIEW_HPP