Replace bazel_re::Digest in LocalCAS::Split/Splice

...with ArtifactDigest.

1 files changed, 15 insertions, 61 deletions

diff --git a/src/buildtool/storage/local_cas.hpp b/src/buildtool/storage/local_cas.hpp
index 6f3bbec1..fccd6ea8 100644
--- a/src/buildtool/storage/local_cas.hpp
+++ b/src/buildtool/storage/local_cas.hpp
@@ -157,19 +157,9 @@ class LocalCAS {
     /// \param digest           The digest of a blob to be split.
     /// \returns                Digests of the parts of the large object or an
     /// error code on failure.
-    [[nodiscard]] auto SplitBlob(bazel_re::Digest const& digest) const noexcept
-        -> expected<std::vector<bazel_re::Digest>, LargeObjectError> {
-        auto const a_digest = static_cast<ArtifactDigest>(digest);
-        auto split_result = cas_file_large_.Split(a_digest);
-        if (not split_result) {
-            return unexpected{std::move(split_result).error()};
-        }
-        std::vector<bazel_re::Digest> result;
-        result.reserve(split_result->size());
-        std::copy(split_result->begin(),
-                  split_result->end(),
-                  std::back_inserter(result));
-        return result;
+    [[nodiscard]] auto SplitBlob(ArtifactDigest const& digest) const noexcept
+        -> expected<std::vector<ArtifactDigest>, LargeObjectError> {
+        return cas_file_large_.Split(digest);
     }
 
     /// \brief Splice a blob from parts.
@@ -178,26 +168,12 @@ class LocalCAS {
     /// \param is_executable    Splice the blob with executable permissions.
     /// \return                 The digest of the result or an error code on
     /// failure.
-    [[nodiscard]] auto SpliceBlob(bazel_re::Digest const& digest,
-                                  std::vector<bazel_re::Digest> const& parts,
+    [[nodiscard]] auto SpliceBlob(ArtifactDigest const& digest,
+                                  std::vector<ArtifactDigest> const& parts,
                                   bool is_executable) const noexcept
-        -> expected<bazel_re::Digest, LargeObjectError> {
-        auto const a_digest = static_cast<ArtifactDigest>(digest);
-        std::vector<ArtifactDigest> a_parts;
-        a_parts.reserve(parts.size());
-        std::transform(
-            parts.begin(),
-            parts.end(),
-            std::back_inserter(a_parts),
-            [](auto const& digest) { return ArtifactDigest{digest}; });
-        auto splice_result =
-            is_executable ? Splice<ObjectType::Executable>(a_digest, a_parts)
-                          : Splice<ObjectType::File>(a_digest, a_parts);
-
-        if (not splice_result) {
-            return unexpected{std::move(splice_result).error()};
-        }
-        return static_cast<bazel_re::Digest>(*splice_result);
+        -> expected<ArtifactDigest, LargeObjectError> {
+        return is_executable ? Splice<ObjectType::Executable>(digest, parts)
+                             : Splice<ObjectType::File>(digest, parts);
     }
 
     /// \brief Obtain tree path from digest.
@@ -212,19 +188,9 @@ class LocalCAS {
     /// \param digest           The digest of a tree to be split.
     /// \returns                Digests of the parts of the large object or an
     /// error code on failure.
-    [[nodiscard]] auto SplitTree(bazel_re::Digest const& digest) const noexcept
-        -> expected<std::vector<bazel_re::Digest>, LargeObjectError> {
-        auto const a_digest = static_cast<ArtifactDigest>(digest);
-        auto split_result = cas_tree_large_.Split(a_digest);
-        if (not split_result) {
-            return unexpected{std::move(split_result).error()};
-        }
-        std::vector<bazel_re::Digest> result;
-        result.reserve(split_result->size());
-        std::copy(split_result->begin(),
-                  split_result->end(),
-                  std::back_inserter(result));
-        return result;
+    [[nodiscard]] auto SplitTree(ArtifactDigest const& digest) const noexcept
+        -> expected<std::vector<ArtifactDigest>, LargeObjectError> {
+        return cas_tree_large_.Split(digest);
     }
 
     /// \brief Splice a tree from parts.
@@ -232,22 +198,10 @@ class LocalCAS {
     /// \param parts            The parts of the large object.
     /// \return                 The digest of the result or an error code on
     /// failure.
-    [[nodiscard]] auto SpliceTree(bazel_re::Digest const& digest,
-                                  std::vector<bazel_re::Digest> const& parts)
-        const noexcept -> expected<bazel_re::Digest, LargeObjectError> {
-        auto const a_digest = static_cast<ArtifactDigest>(digest);
-        std::vector<ArtifactDigest> a_parts;
-        a_parts.reserve(parts.size());
-        std::transform(
-            parts.begin(),
-            parts.end(),
-            std::back_inserter(a_parts),
-            [](auto const& digest) { return ArtifactDigest{digest}; });
-        auto splice_result = Splice<ObjectType::Tree>(a_digest, a_parts);
-        if (not splice_result) {
-            return unexpected{std::move(splice_result).error()};
-        }
-        return static_cast<bazel_re::Digest>(*splice_result);
+    [[nodiscard]] auto SpliceTree(ArtifactDigest const& digest,
+                                  std::vector<ArtifactDigest> const& parts)
+        const noexcept -> expected<ArtifactDigest, LargeObjectError> {
+        return Splice<ObjectType::Tree>(digest, parts);
     }
 
     /// \brief Check whether all parts of the tree are in the storage.