Method AppendBlock

cpp/src/arrow/filesystem/azurefs.cc:1326–1364

  }

  Status AppendBlock(const void* data, int64_t nbytes,
                     std::shared_ptr<Buffer> owned_buffer = nullptr) {
    RETURN_NOT_OK(CheckClosed("append"));

    if (nbytes == 0) {
      return Status::OK();
    }

    const auto block_id = CreateBlock();

    if (background_writes_) {
      if (owned_buffer == nullptr) {
        ARROW_ASSIGN_OR_RAISE(owned_buffer, AllocateBuffer(nbytes, io_context_.pool()));
        memcpy(owned_buffer->mutable_data(), data, nbytes);
      } else {
        DCHECK_EQ(data, owned_buffer->data());
        DCHECK_EQ(nbytes, owned_buffer->size());
      }

      // The closure keeps the buffer and the upload state alive
      auto deferred = [owned_buffer, block_id, block_blob_client = block_blob_client_,
                       state = upload_state_]() mutable -> Status {
        Core::IO::MemoryBodyStream block_content(owned_buffer->data(),
                                                 owned_buffer->size());

        auto status = StageBlock(block_blob_client.get(), block_id, block_content);
        HandleUploadOutcome(state, status);
        return Status::OK();
      };
      RETURN_NOT_OK(io::internal::SubmitIO(io_context_, std::move(deferred)));
    } else {
      auto append_data = reinterpret_cast<const uint8_t*>(data);
      Core::IO::MemoryBodyStream block_content(append_data, nbytes);

      RETURN_NOT_OK(StageBlock(block_blob_client_.get(), block_id, block_content));
    }

    return Status::OK();
  }

  Status AppendBlock(std::shared_ptr<Buffer> buffer) {
    return AppendBlock(buffer->data(), buffer->size(), buffer);