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

...with ArtifactDigest.

3 files changed, 43 insertions, 79 deletions

diff --git a/src/buildtool/execution_api/execution_service/TARGETS b/src/buildtool/execution_api/execution_service/TARGETS
index bf5c10d7..fb88cb05 100644
--- a/src/buildtool/execution_api/execution_service/TARGETS
+++ b/src/buildtool/execution_api/execution_service/TARGETS
@@ -175,7 +175,6 @@
     ]
   , "private-deps":
     [ ["@", "fmt", "", "fmt"]
-    , ["src/buildtool/compatibility", "compatibility"]
     , ["src/buildtool/file_system", "file_system_manager"]
     ]
   }
diff --git a/src/buildtool/execution_api/execution_service/cas_utils.cpp b/src/buildtool/execution_api/execution_service/cas_utils.cpp
index e92a2239..3e1f8002 100644
--- a/src/buildtool/execution_api/execution_service/cas_utils.cpp
+++ b/src/buildtool/execution_api/execution_service/cas_utils.cpp
@@ -15,7 +15,6 @@
 #include "src/buildtool/execution_api/execution_service/cas_utils.hpp"
 
 #include "fmt/core.h"
-#include "src/buildtool/compatibility/native_support.hpp"
 #include "src/buildtool/file_system/file_system_manager.hpp"
 
 static auto ToGrpc(LargeObjectError&& error) noexcept -> grpc::Status {
@@ -48,13 +47,10 @@ auto CASUtils::EnsureTreeInvariant(bazel_re::Digest const& digest,
 auto CASUtils::SplitBlobIdentity(bazel_re::Digest const& blob_digest,
                                  Storage const& storage) noexcept
     -> expected<std::vector<bazel_re::Digest>, grpc::Status> {
-
     // Check blob existence.
-    auto path =
-        NativeSupport::IsTree(blob_digest.hash())
-            ? storage.CAS().TreePath(static_cast<ArtifactDigest>(blob_digest))
-            : storage.CAS().BlobPath(static_cast<ArtifactDigest>(blob_digest),
-                                     false);
+    auto const a_digest = static_cast<ArtifactDigest>(blob_digest);
+    auto path = a_digest.IsTree() ? storage.CAS().TreePath(a_digest)
+                                  : storage.CAS().BlobPath(a_digest, false);
     if (not path) {
         return unexpected{
             grpc::Status{grpc::StatusCode::NOT_FOUND,
@@ -66,7 +62,7 @@ auto CASUtils::SplitBlobIdentity(bazel_re::Digest const& blob_digest,
     // return the identity of a tree, we need to put the tree data in file CAS
     // and return the resulting digest.
     auto chunk_digests = std::vector<bazel_re::Digest>{};
-    if (NativeSupport::IsTree(blob_digest.hash())) {
+    if (a_digest.IsTree()) {
         auto tree_data = FileSystemManager::ReadFile(*path);
         if (not tree_data) {
             return unexpected{grpc::Status{
@@ -91,13 +87,21 @@ auto CASUtils::SplitBlobFastCDC(bazel_re::Digest const& blob_digest,
                                 Storage const& storage) noexcept
     -> expected<std::vector<bazel_re::Digest>, grpc::Status> {
     // Split blob into chunks:
-    auto split = NativeSupport::IsTree(blob_digest.hash())
-                     ? storage.CAS().SplitTree(blob_digest)
-                     : storage.CAS().SplitBlob(blob_digest);
+    auto const a_digest = static_cast<ArtifactDigest>(blob_digest);
+    auto split = a_digest.IsTree() ? storage.CAS().SplitTree(a_digest)
+                                   : storage.CAS().SplitBlob(a_digest);
 
     // Process result:
     if (split) {
-        return *std::move(split);
+        std::vector<bazel_re::Digest> result;
+        result.reserve(split->size());
+        std::transform(split->begin(),
+                       split->end(),
+                       std::back_inserter(result),
+                       [](ArtifactDigest const& digest) {
+                           return static_cast<bazel_re::Digest>(digest);
+                       });
+        return result;
     }
     // Process errors
     return unexpected{ToGrpc(std::move(split).error())};
@@ -107,15 +111,22 @@ auto CASUtils::SpliceBlob(bazel_re::Digest const& blob_digest,
                           std::vector<bazel_re::Digest> const& chunk_digests,
                           Storage const& storage) noexcept
     -> expected<bazel_re::Digest, grpc::Status> {
+    auto const a_digest = static_cast<ArtifactDigest>(blob_digest);
+    std::vector<ArtifactDigest> a_parts;
+    a_parts.reserve(chunk_digests.size());
+    std::transform(chunk_digests.begin(),
+                   chunk_digests.end(),
+                   std::back_inserter(a_parts),
+                   [](auto const& digest) { return ArtifactDigest{digest}; });
+
     // Splice blob from chunks:
-    auto splice =
-        NativeSupport::IsTree(blob_digest.hash())
-            ? storage.CAS().SpliceTree(blob_digest, chunk_digests)
-            : storage.CAS().SpliceBlob(blob_digest, chunk_digests, false);
+    auto splice = a_digest.IsTree()
+                      ? storage.CAS().SpliceTree(a_digest, a_parts)
+                      : storage.CAS().SpliceBlob(a_digest, a_parts, false);
 
     // Process result:
     if (splice) {
-        return *std::move(splice);
+        return static_cast<bazel_re::Digest>(*splice);
     }
     return unexpected{ToGrpc(std::move(splice).error())};
 }
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.