Method DoWrite

cpp/src/arrow/filesystem/azurefs.cc:1232–1290

  }

  Status DoWrite(const void* data, int64_t nbytes,
                 std::shared_ptr<Buffer> owned_buffer = nullptr) {
    if (closed_) {
      return Status::Invalid("Operation on closed stream");
    }

    const auto* data_ptr = reinterpret_cast<const int8_t*>(data);
    auto advance_ptr = [this, &data_ptr, &nbytes](const int64_t offset) {
      data_ptr += offset;
      nbytes -= offset;
      pos_ += offset;
      content_length_ += offset;
    };

    // Handle case where we have some bytes buffered from prior calls.
    if (current_block_size_ > 0) {
      // Try to fill current buffer
      const int64_t to_copy =
          std::min(nbytes, kBlockUploadSizeBytes - current_block_size_);
      RETURN_NOT_OK(current_block_->Write(data_ptr, to_copy));
      current_block_size_ += to_copy;
      advance_ptr(to_copy);

      // If buffer isn't full, break
      if (current_block_size_ < kBlockUploadSizeBytes) {
        return Status::OK();
      }

      // Upload current buffer
      RETURN_NOT_OK(AppendCurrentBlock());
    }

    // We can upload chunks without copying them into a buffer
    while (nbytes >= kBlockUploadSizeBytes) {
      const auto upload_size = std::min(nbytes, kMaxBlockSizeBytes);
      RETURN_NOT_OK(AppendBlock(data_ptr, upload_size));
      advance_ptr(upload_size);
    }

    // Buffer remaining bytes
    if (nbytes > 0) {
      current_block_size_ = nbytes;

      if (current_block_ == nullptr) {
        ARROW_ASSIGN_OR_RAISE(
            current_block_,
            io::BufferOutputStream::Create(kBlockUploadSizeBytes, io_context_.pool()));
      } else {
        // Re-use the allocation from before.
        RETURN_NOT_OK(current_block_->Reset(kBlockUploadSizeBytes, io_context_.pool()));
      }

      RETURN_NOT_OK(current_block_->Write(data_ptr, current_block_size_));
      pos_ += current_block_size_;
      content_length_ += current_block_size_;
    }

    return Status::OK();