refactor: simplify block_decompressor API

include/dwarfs/block_compressor.h

@@ -122,7 +122,7 @@ class block_compressor {
 
 class block_decompressor {
  public:
-  block_decompressor(compression_type type, uint8_t const* data, size_t size,
+  block_decompressor(compression_type type, std::span<uint8_t const> data,
                      mutable_byte_buffer target);
 
   bool decompress_frame(size_t frame_size = BUFSIZ) {
@@ -136,18 +136,13 @@ class block_decompressor {
   std::optional<std::string> metadata() const { return impl_->metadata(); }
 
   static shared_byte_buffer
-  decompress(compression_type type, uint8_t const* data, size_t size) {
+  decompress(compression_type type, std::span<uint8_t const> data) {
     auto target = vector_byte_buffer::create();
-    block_decompressor bd(type, data, size, target);
+    block_decompressor bd(type, data, target);
     bd.decompress_frame(bd.uncompressed_size());
     return target.share();
   }
 
-  static shared_byte_buffer
-  decompress(compression_type type, std::span<uint8_t const> data) {
-    return decompress(type, data.data(), data.size());
-  }
-
   class impl {
    public:
     virtual ~impl() = default;

src/block_compressor.cpp

@@ -41,10 +41,10 @@ block_compressor::block_compressor(std::string const& spec) {
 }
 
 block_decompressor::block_decompressor(compression_type type,
-                                       uint8_t const* data, size_t size,
+                                       std::span<uint8_t const> data,
                                        mutable_byte_buffer target) {
-  impl_ = compression_registry::instance().make_decompressor(
+  impl_ = compression_registry::instance().make_decompressor(type, data,
-      type, std::span<uint8_t const>(data, size), target);
+                                                             std::move(target));
 }
 
 compression_registry& compression_registry::instance() {

src/reader/filesystem_v2.cpp

@@ -106,7 +106,7 @@ block_decompressor get_block_decompressor(mmif& mm, fs_section const& sec) {
 
   auto tmp = vector_byte_buffer::create();
   auto span = sec.data(mm);
-  return {sec.compression(), span.data(), span.size(), tmp};
+  return {sec.compression(), span, tmp};
 }
 
 std::optional<block_decompressor>

src/reader/internal/cached_block.cpp

@@ -49,7 +49,7 @@ class cached_block_ final : public cached_block {
                 bool release, bool disable_integrity_check)
       : data_{vector_byte_buffer::create()}
       , decompressor_{std::make_unique<block_decompressor>(
-            b.compression(), mm->as<uint8_t>(b.start()), b.length(), data_)}
+            b.compression(), mm->span<uint8_t>(b.start(), b.length()), data_)}
       , mm_(std::move(mm))
       , section_(b)
       , LOG_PROXY_INIT(lgr)

src/writer/filesystem_writer.cpp

@@ -386,22 +386,21 @@ class rewritten_fsblock : public fsblock::impl {
 
             {
               // TODO: we don't have to do this for uncompressed blocks
-              auto data = vector_byte_buffer::create();
+              auto buffer = vector_byte_buffer::create();
-              block_decompressor bd(data_comp_type_, data_.data(), data_.size(),
+              block_decompressor bd(data_comp_type_, data_, buffer);
-                                    data);
               bd.decompress_frame(bd.uncompressed_size());
 
               if (!meta) {
                 meta = bd.metadata();
               }
 
-              pctx_->bytes_in += data.size(); // TODO: data_.size()?
+              pctx_->bytes_in += buffer.size(); // TODO: data_.size()?
 
               try {
                 if (meta) {
-                  block = bc_.compress(data.span(), *meta);
+                  block = bc_.compress(buffer.span(), *meta);
                 } else {
-                  block = bc_.compress(data.span());
+                  block = bc_.compress(buffer.span());
                 }
               } catch (bad_compression_ratio_error const&) {
                 comp_type_ = compression_type::NONE;
@@ -883,7 +882,7 @@ void filesystem_writer_<LoggerPolicy>::check_block_compression(
     auto req = compression_metadata_requirements<nlohmann::json>{reqstr};
 
     auto tmp = vector_byte_buffer::create();
-    block_decompressor bd(compression, data.data(), data.size(), tmp);
+    block_decompressor bd(compression, data, tmp);
 
     try {
       req.check(bd.metadata());

test/flac_compressor_test.cpp

@@ -150,8 +150,8 @@ TEST(flac_compressor, basic) {
 
   EXPECT_LT(compressed.size(), data.size() / 2);
 
-  auto decompressed = block_decompressor::decompress(
+  auto decompressed =
-      compression_type::FLAC, compressed.data(), compressed.size());
+      block_decompressor::decompress(compression_type::FLAC, compressed);
 
   EXPECT_EQ(data, decompressed);
 }
@@ -183,8 +183,8 @@ TEST_P(flac_param, combinations) {
 
   EXPECT_LT(compressed.size(), data.size() / 2);
 
-  auto decompressed = block_decompressor::decompress(
+  auto decompressed =
-      compression_type::FLAC, compressed.data(), compressed.size());
+      block_decompressor::decompress(compression_type::FLAC, compressed);
 
   EXPECT_EQ(data, decompressed);
 }

test/ricepp_compressor_test.cpp

@@ -151,8 +151,8 @@ TEST_P(ricepp_param, combinations) {
 
   EXPECT_LT(compressed.size(), 7 * data.size() / 10);
 
-  auto decompressed = block_decompressor::decompress(
+  auto decompressed =
-      compression_type::RICEPP, compressed.data(), compressed.size());
+      block_decompressor::decompress(compression_type::RICEPP, compressed);
 
   ASSERT_EQ(data.size(), decompressed.size());
   EXPECT_EQ(data, decompressed);