[
https://issues.apache.org/jira/browse/ARROW-1850?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16267035#comment-16267035
]
ASF GitHub Bot commented on ARROW-1850:
---------------------------------------
wesm closed pull request #1363: ARROW-1850: [C++] Use void* / const void* for
buffers in file APIs
URL: https://github.com/apache/arrow/pull/1363
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/c_glib/arrow-glib/input-stream.cpp
b/c_glib/arrow-glib/input-stream.cpp
index a7a894b9d..94422241b 100644
--- a/c_glib/arrow-glib/input-stream.cpp
+++ b/c_glib/arrow-glib/input-stream.cpp
@@ -420,7 +420,7 @@ namespace garrow {
arrow::Status Read(int64_t n_bytes,
int64_t *n_read_bytes,
- uint8_t *out) override {
+ void *out) override {
GError *error = NULL;
*n_read_bytes = g_input_stream_read(input_stream_,
out,
@@ -437,7 +437,7 @@ namespace garrow {
}
arrow::Status ReadAt(int64_t position, int64_t n_bytes,
- int64_t *n_read_bytes, uint8_t* out) override {
+ int64_t *n_read_bytes, void* out) override {
return arrow::io::RandomAccessFile::ReadAt(
position, n_bytes, n_read_bytes, out);
}
diff --git a/c_glib/arrow-glib/output-stream.cpp
b/c_glib/arrow-glib/output-stream.cpp
index 739992fb6..9939f4f08 100644
--- a/c_glib/arrow-glib/output-stream.cpp
+++ b/c_glib/arrow-glib/output-stream.cpp
@@ -76,7 +76,7 @@ garrow_output_stream_file_interface_init(GArrowFileInterface
*iface)
iface->get_raw = garrow_output_stream_get_raw_file_interface;
}
-static std::shared_ptr<arrow::io::Writeable>
+static std::shared_ptr<arrow::io::Writable>
garrow_output_stream_get_raw_writeable_interface(GArrowWriteable *writeable)
{
auto output_stream = GARROW_OUTPUT_STREAM(writeable);
@@ -325,7 +325,7 @@ namespace garrow {
return arrow::Status::OK();
}
- arrow::Status Write(const uint8_t *data,
+ arrow::Status Write(const void *data,
int64_t n_bytes) override {
GError *error = NULL;
gsize n_written_bytes;
diff --git a/c_glib/arrow-glib/writeable.cpp b/c_glib/arrow-glib/writeable.cpp
index eb6adfee8..a16e43ab1 100644
--- a/c_glib/arrow-glib/writeable.cpp
+++ b/c_glib/arrow-glib/writeable.cpp
@@ -88,7 +88,7 @@ garrow_writeable_flush(GArrowWriteable *writeable,
G_END_DECLS
-std::shared_ptr<arrow::io::Writeable>
+std::shared_ptr<arrow::io::Writable>
garrow_writeable_get_raw(GArrowWriteable *writeable)
{
auto *iface = GARROW_WRITEABLE_GET_IFACE(writeable);
diff --git a/c_glib/arrow-glib/writeable.hpp b/c_glib/arrow-glib/writeable.hpp
index 2b398f8b5..806d36fc0 100644
--- a/c_glib/arrow-glib/writeable.hpp
+++ b/c_glib/arrow-glib/writeable.hpp
@@ -26,13 +26,13 @@
/**
* GArrowWriteableInterface:
*
- * It wraps `arrow::io::Writeable`.
+ * It wraps `arrow::io::Writable`.
*/
struct _GArrowWriteableInterface
{
GTypeInterface parent_iface;
- std::shared_ptr<arrow::io::Writeable> (*get_raw)(GArrowWriteable *file);
+ std::shared_ptr<arrow::io::Writable> (*get_raw)(GArrowWriteable *file);
};
-std::shared_ptr<arrow::io::Writeable> garrow_writeable_get_raw(GArrowWriteable
*writeable);
+std::shared_ptr<arrow::io::Writable> garrow_writeable_get_raw(GArrowWriteable
*writeable);
diff --git a/cpp/src/arrow/gpu/CMakeLists.txt b/cpp/src/arrow/gpu/CMakeLists.txt
index 3f3069b91..3ddf2c797 100644
--- a/cpp/src/arrow/gpu/CMakeLists.txt
+++ b/cpp/src/arrow/gpu/CMakeLists.txt
@@ -54,7 +54,7 @@ configure_file(cuda_version.h.in
@ONLY)
install(FILES
- "${CMAKE_CURRENT_SOURCE_DIR}/cuda_version.h"
+ "${CMAKE_CURRENT_BINARY_DIR}/cuda_version.h"
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/arrow/gpu")
install(FILES
diff --git a/cpp/src/arrow/gpu/cuda_context.cc
b/cpp/src/arrow/gpu/cuda_context.cc
index fff8ece6c..2f5ccb0a9 100644
--- a/cpp/src/arrow/gpu/cuda_context.cc
+++ b/cpp/src/arrow/gpu/cuda_context.cc
@@ -69,28 +69,27 @@ class CudaContext::CudaContextImpl {
return Status::OK();
}
- Status CopyHostToDevice(uint8_t* dst, const uint8_t* src, int64_t nbytes) {
+ Status CopyHostToDevice(void* dst, const void* src, int64_t nbytes) {
CU_RETURN_NOT_OK(cuCtxSetCurrent(context_));
- CU_RETURN_NOT_OK(cuMemcpyHtoD(reinterpret_cast<CUdeviceptr>(dst),
- reinterpret_cast<const void*>(src),
+ CU_RETURN_NOT_OK(cuMemcpyHtoD(reinterpret_cast<CUdeviceptr>(dst), src,
static_cast<size_t>(nbytes)));
return Status::OK();
}
- Status CopyDeviceToHost(uint8_t* dst, const uint8_t* src, int64_t nbytes) {
+ Status CopyDeviceToHost(void* dst, const void* src, int64_t nbytes) {
CU_RETURN_NOT_OK(cuCtxSetCurrent(context_));
CU_RETURN_NOT_OK(cuMemcpyDtoH(dst, reinterpret_cast<const
CUdeviceptr>(src),
static_cast<size_t>(nbytes)));
return Status::OK();
}
- Status Free(uint8_t* device_ptr, int64_t nbytes) {
+ Status Free(void* device_ptr, int64_t nbytes) {
CU_RETURN_NOT_OK(cuMemFree(reinterpret_cast<CUdeviceptr>(device_ptr)));
bytes_allocated_ -= nbytes;
return Status::OK();
}
- Status ExportIpcBuffer(uint8_t* data, std::unique_ptr<CudaIpcMemHandle>*
handle) {
+ Status ExportIpcBuffer(void* data, std::unique_ptr<CudaIpcMemHandle>*
handle) {
CU_RETURN_NOT_OK(cuCtxSetCurrent(context_));
CUipcMemHandle cu_handle;
CU_RETURN_NOT_OK(cuIpcGetMemHandle(&cu_handle,
reinterpret_cast<CUdeviceptr>(data)));
@@ -145,7 +144,7 @@ class CudaDeviceManager::CudaDeviceManagerImpl {
return Status::OK();
}
- Status FreeHost(uint8_t* data, int64_t nbytes) {
+ Status FreeHost(void* data, int64_t nbytes) {
CU_RETURN_NOT_OK(cuMemFreeHost(data));
host_bytes_allocated_ -= nbytes;
return Status::OK();
@@ -221,7 +220,7 @@ Status CudaDeviceManager::AllocateHost(int64_t nbytes,
return Status::OK();
}
-Status CudaDeviceManager::FreeHost(uint8_t* data, int64_t nbytes) {
+Status CudaDeviceManager::FreeHost(void* data, int64_t nbytes) {
return impl_->FreeHost(data, nbytes);
}
@@ -241,22 +240,22 @@ Status CudaContext::Allocate(int64_t nbytes,
std::shared_ptr<CudaBuffer>* out) {
return Status::OK();
}
-Status CudaContext::ExportIpcBuffer(uint8_t* data,
+Status CudaContext::ExportIpcBuffer(void* data,
std::unique_ptr<CudaIpcMemHandle>* handle)
{
return impl_->ExportIpcBuffer(data, handle);
}
-Status CudaContext::CopyHostToDevice(uint8_t* dst, const uint8_t* src, int64_t
nbytes) {
+Status CudaContext::CopyHostToDevice(void* dst, const void* src, int64_t
nbytes) {
return impl_->CopyHostToDevice(dst, src, nbytes);
}
-Status CudaContext::CopyDeviceToHost(uint8_t* dst, const uint8_t* src, int64_t
nbytes) {
+Status CudaContext::CopyDeviceToHost(void* dst, const void* src, int64_t
nbytes) {
return impl_->CopyDeviceToHost(dst, src, nbytes);
}
Status CudaContext::Close() { return impl_->Close(); }
-Status CudaContext::Free(uint8_t* device_ptr, int64_t nbytes) {
+Status CudaContext::Free(void* device_ptr, int64_t nbytes) {
return impl_->Free(device_ptr, nbytes);
}
diff --git a/cpp/src/arrow/gpu/cuda_context.h b/cpp/src/arrow/gpu/cuda_context.h
index 647105961..6fc2e0d08 100644
--- a/cpp/src/arrow/gpu/cuda_context.h
+++ b/cpp/src/arrow/gpu/cuda_context.h
@@ -46,7 +46,7 @@ class ARROW_EXPORT CudaDeviceManager {
Status AllocateHost(int64_t nbytes, std::shared_ptr<CudaHostBuffer>* buffer);
- Status FreeHost(uint8_t* data, int64_t nbytes);
+ Status FreeHost(void* data, int64_t nbytes);
int num_devices() const;
@@ -88,10 +88,10 @@ class ARROW_EXPORT CudaContext : public
std::enable_shared_from_this<CudaContext
private:
CudaContext();
- Status ExportIpcBuffer(uint8_t* data, std::unique_ptr<CudaIpcMemHandle>*
handle);
- Status CopyHostToDevice(uint8_t* dst, const uint8_t* src, int64_t nbytes);
- Status CopyDeviceToHost(uint8_t* dst, const uint8_t* src, int64_t nbytes);
- Status Free(uint8_t* device_ptr, int64_t nbytes);
+ Status ExportIpcBuffer(void* data, std::unique_ptr<CudaIpcMemHandle>*
handle);
+ Status CopyHostToDevice(void* dst, const void* src, int64_t nbytes);
+ Status CopyDeviceToHost(void* dst, const void* src, int64_t nbytes);
+ Status Free(void* device_ptr, int64_t nbytes);
class CudaContextImpl;
std::unique_ptr<CudaContextImpl> impl_;
diff --git a/cpp/src/arrow/gpu/cuda_memory.cc b/cpp/src/arrow/gpu/cuda_memory.cc
index 949c1d7a4..cbf044121 100644
--- a/cpp/src/arrow/gpu/cuda_memory.cc
+++ b/cpp/src/arrow/gpu/cuda_memory.cc
@@ -101,11 +101,11 @@ CudaBuffer::CudaBuffer(const std::shared_ptr<CudaBuffer>&
parent, const int64_t
is_ipc_(false) {}
Status CudaBuffer::CopyToHost(const int64_t position, const int64_t nbytes,
- uint8_t* out) const {
+ void* out) const {
return context_->CopyDeviceToHost(out, data_ + position, nbytes);
}
-Status CudaBuffer::CopyFromHost(const int64_t position, const uint8_t* data,
+Status CudaBuffer::CopyFromHost(const int64_t position, const void* data,
int64_t nbytes) {
DCHECK_LE(nbytes, size_ - position) << "Copy would overflow buffer";
return context_->CopyHostToDevice(mutable_data_ + position, data, nbytes);
@@ -134,7 +134,7 @@ CudaBufferReader::CudaBufferReader(const
std::shared_ptr<CudaBuffer>& buffer)
CudaBufferReader::~CudaBufferReader() {}
-Status CudaBufferReader::Read(int64_t nbytes, int64_t* bytes_read, uint8_t*
buffer) {
+Status CudaBufferReader::Read(int64_t nbytes, int64_t* bytes_read, void*
buffer) {
nbytes = std::min(nbytes, size_ - position_);
*bytes_read = nbytes;
RETURN_NOT_OK(context_->CopyDeviceToHost(buffer, data_ + position_, nbytes));
@@ -190,7 +190,7 @@ class CudaBufferWriter::CudaBufferWriterImpl {
return Status::OK();
}
- Status Write(const uint8_t* data, int64_t nbytes) {
+ Status Write(const void* data, int64_t nbytes) {
if (nbytes == 0) {
return Status::OK();
}
@@ -214,7 +214,7 @@ class CudaBufferWriter::CudaBufferWriterImpl {
return Status::OK();
}
- Status WriteAt(int64_t position, const uint8_t* data, int64_t nbytes) {
+ Status WriteAt(int64_t position, const void* data, int64_t nbytes) {
std::lock_guard<std::mutex> guard(lock_);
RETURN_NOT_OK(Seek(position));
return Write(data, nbytes);
@@ -269,11 +269,11 @@ Status CudaBufferWriter::Seek(int64_t position) {
Status CudaBufferWriter::Tell(int64_t* position) const { return
impl_->Tell(position); }
-Status CudaBufferWriter::Write(const uint8_t* data, int64_t nbytes) {
+Status CudaBufferWriter::Write(const void* data, int64_t nbytes) {
return impl_->Write(data, nbytes);
}
-Status CudaBufferWriter::WriteAt(int64_t position, const uint8_t* data,
int64_t nbytes) {
+Status CudaBufferWriter::WriteAt(int64_t position, const void* data, int64_t
nbytes) {
return impl_->WriteAt(position, data, nbytes);
}
diff --git a/cpp/src/arrow/gpu/cuda_memory.h b/cpp/src/arrow/gpu/cuda_memory.h
index 9ebd2ccf0..9376b4b3f 100644
--- a/cpp/src/arrow/gpu/cuda_memory.h
+++ b/cpp/src/arrow/gpu/cuda_memory.h
@@ -49,14 +49,14 @@ class ARROW_EXPORT CudaBuffer : public Buffer {
/// \brief Copy memory from GPU device to CPU host
/// \param[out] out a pre-allocated output buffer
/// \return Status
- Status CopyToHost(const int64_t position, const int64_t nbytes, uint8_t*
out) const;
+ Status CopyToHost(const int64_t position, const int64_t nbytes, void* out)
const;
/// \brief Copy memory to device at position
/// \param[in] position start position to copy bytes
/// \param[in] data the host data to copy
/// \param[in] nbytes number of bytes to copy
/// \return Status
- Status CopyFromHost(const int64_t position, const uint8_t* data, int64_t
nbytes);
+ Status CopyFromHost(const int64_t position, const void* data, int64_t
nbytes);
/// \brief Expose this device buffer as IPC memory which can be used in
other processes
/// \param[out] handle the exported IPC handle
@@ -130,7 +130,7 @@ class ARROW_EXPORT CudaBufferReader : public
io::BufferReader {
/// \param[in] nbytes number of bytes to read
/// \param[out] bytes_read actual number of bytes read
/// \param[out] buffer pre-allocated memory to write into
- Status Read(int64_t nbytes, int64_t* bytes_read, uint8_t* buffer) override;
+ Status Read(int64_t nbytes, int64_t* bytes_read, void* buffer) override;
/// \brief Zero-copy read from device memory
/// \param[in] nbytes number of bytes to read
@@ -158,9 +158,9 @@ class ARROW_EXPORT CudaBufferWriter : public
io::WriteableFile {
Status Seek(int64_t position) override;
- Status Write(const uint8_t* data, int64_t nbytes) override;
+ Status Write(const void* data, int64_t nbytes) override;
- Status WriteAt(int64_t position, const uint8_t* data, int64_t nbytes)
override;
+ Status WriteAt(int64_t position, const void* data, int64_t nbytes) override;
Status Tell(int64_t* position) const override;
diff --git a/cpp/src/arrow/io/file.cc b/cpp/src/arrow/io/file.cc
index 1ec5e23e5..65a302c8b 100644
--- a/cpp/src/arrow/io/file.cc
+++ b/cpp/src/arrow/io/file.cc
@@ -394,11 +394,11 @@ class OSFile {
return Status::OK();
}
- Status Read(int64_t nbytes, int64_t* bytes_read, uint8_t* out) {
- return FileRead(fd_, out, nbytes, bytes_read);
+ Status Read(int64_t nbytes, int64_t* bytes_read, void* out) {
+ return FileRead(fd_, reinterpret_cast<uint8_t*>(out), nbytes, bytes_read);
}
- Status ReadAt(int64_t position, int64_t nbytes, int64_t* bytes_read,
uint8_t* out) {
+ Status ReadAt(int64_t position, int64_t nbytes, int64_t* bytes_read, void*
out) {
std::lock_guard<std::mutex> guard(lock_);
RETURN_NOT_OK(Seek(position));
return Read(nbytes, bytes_read, out);
@@ -413,12 +413,12 @@ class OSFile {
Status Tell(int64_t* pos) const { return FileTell(fd_, pos); }
- Status Write(const uint8_t* data, int64_t length) {
+ Status Write(const void* data, int64_t length) {
std::lock_guard<std::mutex> guard(lock_);
if (length < 0) {
return Status::IOError("Length must be non-negative");
}
- return FileWrite(fd_, data, length);
+ return FileWrite(fd_, reinterpret_cast<const uint8_t*>(data), length);
}
int fd() const { return fd_; }
@@ -504,13 +504,13 @@ Status ReadableFile::Close() { return impl_->Close(); }
Status ReadableFile::Tell(int64_t* pos) const { return impl_->Tell(pos); }
-Status ReadableFile::Read(int64_t nbytes, int64_t* bytes_read, uint8_t* out) {
+Status ReadableFile::Read(int64_t nbytes, int64_t* bytes_read, void* out) {
std::lock_guard<std::mutex> guard(impl_->lock());
return impl_->Read(nbytes, bytes_read, out);
}
Status ReadableFile::ReadAt(int64_t position, int64_t nbytes, int64_t*
bytes_read,
- uint8_t* out) {
+ void* out) {
return impl_->ReadAt(position, nbytes, bytes_read, out);
}
@@ -570,7 +570,7 @@ Status FileOutputStream::Close() { return impl_->Close(); }
Status FileOutputStream::Tell(int64_t* pos) const { return impl_->Tell(pos); }
-Status FileOutputStream::Write(const uint8_t* data, int64_t length) {
+Status FileOutputStream::Write(const void* data, int64_t length) {
return impl_->Write(data, length);
}
@@ -710,7 +710,7 @@ Status MemoryMappedFile::Close() {
return Status::OK();
}
-Status MemoryMappedFile::Read(int64_t nbytes, int64_t* bytes_read, uint8_t*
out) {
+Status MemoryMappedFile::Read(int64_t nbytes, int64_t* bytes_read, void* out) {
nbytes = std::max<int64_t>(
0, std::min(nbytes, memory_map_->size() - memory_map_->position()));
if (nbytes > 0) {
@@ -735,7 +735,7 @@ Status MemoryMappedFile::Read(int64_t nbytes,
std::shared_ptr<Buffer>* out) {
}
Status MemoryMappedFile::ReadAt(int64_t position, int64_t nbytes, int64_t*
bytes_read,
- uint8_t* out) {
+ void* out) {
std::lock_guard<std::mutex> guard(memory_map_->lock());
RETURN_NOT_OK(Seek(position));
return Read(nbytes, bytes_read, out);
@@ -750,7 +750,7 @@ Status MemoryMappedFile::ReadAt(int64_t position, int64_t
nbytes,
bool MemoryMappedFile::supports_zero_copy() const { return true; }
-Status MemoryMappedFile::WriteAt(int64_t position, const uint8_t* data,
int64_t nbytes) {
+Status MemoryMappedFile::WriteAt(int64_t position, const void* data, int64_t
nbytes) {
std::lock_guard<std::mutex> guard(memory_map_->lock());
if (!memory_map_->opened() || !memory_map_->writable()) {
@@ -761,7 +761,7 @@ Status MemoryMappedFile::WriteAt(int64_t position, const
uint8_t* data, int64_t
return WriteInternal(data, nbytes);
}
-Status MemoryMappedFile::Write(const uint8_t* data, int64_t nbytes) {
+Status MemoryMappedFile::Write(const void* data, int64_t nbytes) {
std::lock_guard<std::mutex> guard(memory_map_->lock());
if (!memory_map_->opened() || !memory_map_->writable()) {
@@ -773,7 +773,7 @@ Status MemoryMappedFile::Write(const uint8_t* data, int64_t
nbytes) {
return WriteInternal(data, nbytes);
}
-Status MemoryMappedFile::WriteInternal(const uint8_t* data, int64_t nbytes) {
+Status MemoryMappedFile::WriteInternal(const void* data, int64_t nbytes) {
memcpy(memory_map_->head(), data, static_cast<size_t>(nbytes));
memory_map_->advance(nbytes);
return Status::OK();
diff --git a/cpp/src/arrow/io/file.h b/cpp/src/arrow/io/file.h
index 7937fea74..265df4d65 100644
--- a/cpp/src/arrow/io/file.h
+++ b/cpp/src/arrow/io/file.h
@@ -59,7 +59,7 @@ class ARROW_EXPORT FileOutputStream : public OutputStream {
Status Tell(int64_t* position) const override;
// Write bytes to the stream. Thread-safe
- Status Write(const uint8_t* data, int64_t nbytes) override;
+ Status Write(const void* data, int64_t nbytes) override;
int file_descriptor() const;
@@ -93,12 +93,12 @@ class ARROW_EXPORT ReadableFile : public RandomAccessFile {
Status Tell(int64_t* position) const override;
// Read bytes from the file. Thread-safe
- Status Read(int64_t nbytes, int64_t* bytes_read, uint8_t* buffer) override;
+ Status Read(int64_t nbytes, int64_t* bytes_read, void* buffer) override;
Status Read(int64_t nbytes, std::shared_ptr<Buffer>* out) override;
/// \brief Thread-safe implementation of ReadAt
Status ReadAt(int64_t position, int64_t nbytes, int64_t* bytes_read,
- uint8_t* out) override;
+ void* out) override;
/// \brief Thread-safe implementation of ReadAt
Status ReadAt(int64_t position, int64_t nbytes, std::shared_ptr<Buffer>*
out) override;
@@ -141,13 +141,13 @@ class ARROW_EXPORT MemoryMappedFile : public
ReadWriteFileInterface {
Status Seek(int64_t position) override;
// Required by RandomAccessFile, copies memory into out. Not thread-safe
- Status Read(int64_t nbytes, int64_t* bytes_read, uint8_t* out) override;
+ Status Read(int64_t nbytes, int64_t* bytes_read, void* out) override;
// Zero copy read. Not thread-safe
Status Read(int64_t nbytes, std::shared_ptr<Buffer>* out) override;
Status ReadAt(int64_t position, int64_t nbytes, int64_t* bytes_read,
- uint8_t* out) override;
+ void* out) override;
/// Default implementation is thread-safe
Status ReadAt(int64_t position, int64_t nbytes, std::shared_ptr<Buffer>*
out) override;
@@ -155,10 +155,10 @@ class ARROW_EXPORT MemoryMappedFile : public
ReadWriteFileInterface {
bool supports_zero_copy() const override;
/// Write data at the current position in the file. Thread-safe
- Status Write(const uint8_t* data, int64_t nbytes) override;
+ Status Write(const void* data, int64_t nbytes) override;
/// Write data at a particular position in the file. Thread-safe
- Status WriteAt(int64_t position, const uint8_t* data, int64_t nbytes)
override;
+ Status WriteAt(int64_t position, const void* data, int64_t nbytes) override;
// @return: the size in bytes of the memory source
Status GetSize(int64_t* size) override;
@@ -168,7 +168,7 @@ class ARROW_EXPORT MemoryMappedFile : public
ReadWriteFileInterface {
private:
MemoryMappedFile();
- Status WriteInternal(const uint8_t* data, int64_t nbytes);
+ Status WriteInternal(const void* data, int64_t nbytes);
class ARROW_NO_EXPORT MemoryMap;
std::shared_ptr<MemoryMap> memory_map_;
diff --git a/cpp/src/arrow/io/hdfs.cc b/cpp/src/arrow/io/hdfs.cc
index 77d1f524a..6e3e4a7a1 100644
--- a/cpp/src/arrow/io/hdfs.cc
+++ b/cpp/src/arrow/io/hdfs.cc
@@ -119,7 +119,7 @@ class HdfsReadableFile::HdfsReadableFileImpl : public
HdfsAnyFileImpl {
return Status::OK();
}
- Status ReadAt(int64_t position, int64_t nbytes, int64_t* bytes_read,
uint8_t* buffer) {
+ Status ReadAt(int64_t position, int64_t nbytes, int64_t* bytes_read, void*
buffer) {
tSize ret;
if (driver_->HasPread()) {
ret = driver_->Pread(fs_, file_, static_cast<tOffset>(position),
@@ -149,11 +149,11 @@ class HdfsReadableFile::HdfsReadableFileImpl : public
HdfsAnyFileImpl {
return Status::OK();
}
- Status Read(int64_t nbytes, int64_t* bytes_read, uint8_t* buffer) {
+ Status Read(int64_t nbytes, int64_t* bytes_read, void* buffer) {
int64_t total_bytes = 0;
while (total_bytes < nbytes) {
tSize ret = driver_->Read(
- fs_, file_, reinterpret_cast<void*>(buffer + total_bytes),
+ fs_, file_, reinterpret_cast<uint8_t*>(buffer) + total_bytes,
static_cast<tSize>(std::min<int64_t>(buffer_size_, nbytes -
total_bytes)));
RETURN_NOT_OK(CheckReadResult(ret));
total_bytes += ret;
@@ -212,7 +212,7 @@ HdfsReadableFile::~HdfsReadableFile() {
DCHECK(impl_->Close().ok()); }
Status HdfsReadableFile::Close() { return impl_->Close(); }
Status HdfsReadableFile::ReadAt(int64_t position, int64_t nbytes, int64_t*
bytes_read,
- uint8_t* buffer) {
+ void* buffer) {
return impl_->ReadAt(position, nbytes, bytes_read, buffer);
}
@@ -223,7 +223,7 @@ Status HdfsReadableFile::ReadAt(int64_t position, int64_t
nbytes,
bool HdfsReadableFile::supports_zero_copy() const { return false; }
-Status HdfsReadableFile::Read(int64_t nbytes, int64_t* bytes_read, uint8_t*
buffer) {
+Status HdfsReadableFile::Read(int64_t nbytes, int64_t* bytes_read, void*
buffer) {
return impl_->Read(nbytes, bytes_read, buffer);
}
@@ -261,7 +261,7 @@ class HdfsOutputStream::HdfsOutputStreamImpl : public
HdfsAnyFileImpl {
return Status::OK();
}
- Status Write(const uint8_t* buffer, int64_t nbytes, int64_t* bytes_written) {
+ Status Write(const void* buffer, int64_t nbytes, int64_t* bytes_written) {
std::lock_guard<std::mutex> guard(lock_);
tSize ret = driver_->Write(fs_, file_, reinterpret_cast<const
void*>(buffer),
static_cast<tSize>(nbytes));
@@ -277,12 +277,11 @@ HdfsOutputStream::~HdfsOutputStream() {
DCHECK(impl_->Close().ok()); }
Status HdfsOutputStream::Close() { return impl_->Close(); }
-Status HdfsOutputStream::Write(const uint8_t* buffer, int64_t nbytes,
- int64_t* bytes_read) {
+Status HdfsOutputStream::Write(const void* buffer, int64_t nbytes, int64_t*
bytes_read) {
return impl_->Write(buffer, nbytes, bytes_read);
}
-Status HdfsOutputStream::Write(const uint8_t* buffer, int64_t nbytes) {
+Status HdfsOutputStream::Write(const void* buffer, int64_t nbytes) {
int64_t bytes_written_dummy = 0;
return Write(buffer, nbytes, &bytes_written_dummy);
}
diff --git a/cpp/src/arrow/io/hdfs.h b/cpp/src/arrow/io/hdfs.h
index 0708b11cc..062473b20 100644
--- a/cpp/src/arrow/io/hdfs.h
+++ b/cpp/src/arrow/io/hdfs.h
@@ -182,12 +182,12 @@ class ARROW_EXPORT HdfsReadableFile : public
RandomAccessFile {
// NOTE: If you wish to read a particular range of a file in a multithreaded
// context, you may prefer to use ReadAt to avoid locking issues
- Status Read(int64_t nbytes, int64_t* bytes_read, uint8_t* buffer) override;
+ Status Read(int64_t nbytes, int64_t* bytes_read, void* buffer) override;
Status Read(int64_t nbytes, std::shared_ptr<Buffer>* out) override;
Status ReadAt(int64_t position, int64_t nbytes, int64_t* bytes_read,
- uint8_t* buffer) override;
+ void* buffer) override;
Status ReadAt(int64_t position, int64_t nbytes, std::shared_ptr<Buffer>*
out) override;
@@ -217,9 +217,9 @@ class ARROW_EXPORT HdfsOutputStream : public OutputStream {
Status Close() override;
- Status Write(const uint8_t* buffer, int64_t nbytes) override;
+ Status Write(const void* buffer, int64_t nbytes) override;
- Status Write(const uint8_t* buffer, int64_t nbytes, int64_t* bytes_written);
+ Status Write(const void* buffer, int64_t nbytes, int64_t* bytes_written);
Status Flush() override;
diff --git a/cpp/src/arrow/io/interfaces.cc b/cpp/src/arrow/io/interfaces.cc
index 582cc2026..04560209a 100644
--- a/cpp/src/arrow/io/interfaces.cc
+++ b/cpp/src/arrow/io/interfaces.cc
@@ -38,7 +38,7 @@ RandomAccessFile::RandomAccessFile()
: impl_(new RandomAccessFile::RandomAccessFileImpl()) {}
Status RandomAccessFile::ReadAt(int64_t position, int64_t nbytes, int64_t*
bytes_read,
- uint8_t* out) {
+ void* out) {
std::lock_guard<std::mutex> lock(impl_->lock_);
RETURN_NOT_OK(Seek(position));
return Read(nbytes, bytes_read, out);
@@ -51,12 +51,11 @@ Status RandomAccessFile::ReadAt(int64_t position, int64_t
nbytes,
return Read(nbytes, out);
}
-Status Writeable::Write(const std::string& data) {
- return Write(reinterpret_cast<const uint8_t*>(data.c_str()),
- static_cast<int64_t>(data.size()));
+Status Writable::Write(const std::string& data) {
+ return Write(data.c_str(), static_cast<int64_t>(data.size()));
}
-Status Writeable::Flush() { return Status::OK(); }
+Status Writable::Flush() { return Status::OK(); }
} // namespace io
} // namespace arrow
diff --git a/cpp/src/arrow/io/interfaces.h b/cpp/src/arrow/io/interfaces.h
index 82af875e7..09536a44e 100644
--- a/cpp/src/arrow/io/interfaces.h
+++ b/cpp/src/arrow/io/interfaces.h
@@ -86,11 +86,11 @@ class ARROW_EXPORT Seekable {
virtual Status Seek(int64_t position) = 0;
};
-class ARROW_EXPORT Writeable {
+class ARROW_EXPORT Writable {
public:
- virtual ~Writeable() = default;
+ virtual ~Writable() = default;
- virtual Status Write(const uint8_t* data, int64_t nbytes) = 0;
+ virtual Status Write(const void* data, int64_t nbytes) = 0;
/// \brief Flush buffered bytes, if any
virtual Status Flush();
@@ -102,13 +102,13 @@ class ARROW_EXPORT Readable {
public:
virtual ~Readable() = default;
- virtual Status Read(int64_t nbytes, int64_t* bytes_read, uint8_t* out) = 0;
+ virtual Status Read(int64_t nbytes, int64_t* bytes_read, void* out) = 0;
// Does not copy if not necessary
virtual Status Read(int64_t nbytes, std::shared_ptr<Buffer>* out) = 0;
};
-class ARROW_EXPORT OutputStream : virtual public FileInterface, public
Writeable {
+class ARROW_EXPORT OutputStream : virtual public FileInterface, public
Writable {
protected:
OutputStream() = default;
};
@@ -138,7 +138,7 @@ class ARROW_EXPORT RandomAccessFile : public InputStream,
public Seekable {
/// \param[out] out The buffer to read bytes into
/// \return Status
virtual Status ReadAt(int64_t position, int64_t nbytes, int64_t* bytes_read,
- uint8_t* out) = 0;
+ void* out) = 0;
/// \brief Read nbytes at position, provide default implementations using
Read(...), but
/// can be overridden. Default implementation is thread-safe.
@@ -162,7 +162,7 @@ class ARROW_EXPORT RandomAccessFile : public InputStream,
public Seekable {
class ARROW_EXPORT WriteableFile : public OutputStream, public Seekable {
public:
- virtual Status WriteAt(int64_t position, const uint8_t* data, int64_t
nbytes) = 0;
+ virtual Status WriteAt(int64_t position, const void* data, int64_t nbytes) =
0;
protected:
WriteableFile() = default;
diff --git a/cpp/src/arrow/io/io-file-test.cc b/cpp/src/arrow/io/io-file-test.cc
index ee3beabd9..e70431e69 100644
--- a/cpp/src/arrow/io/io-file-test.cc
+++ b/cpp/src/arrow/io/io-file-test.cc
@@ -135,7 +135,7 @@ TEST_F(TestFileOutputStream, Close) {
OpenFile();
const char* data = "testdata";
- ASSERT_OK(file_->Write(reinterpret_cast<const uint8_t*>(data),
strlen(data)));
+ ASSERT_OK(file_->Write(data, strlen(data)));
int fd = file_->file_descriptor();
ASSERT_OK(file_->Close());
@@ -158,7 +158,7 @@ TEST_F(TestFileOutputStream, InvalidWrites) {
const char* data = "";
- ASSERT_RAISES(IOError, file_->Write(reinterpret_cast<const uint8_t*>(data),
-1));
+ ASSERT_RAISES(IOError, file_->Write(data, -1));
}
TEST_F(TestFileOutputStream, Tell) {
@@ -170,7 +170,7 @@ TEST_F(TestFileOutputStream, Tell) {
ASSERT_EQ(0, position);
const char* data = "testdata";
- ASSERT_OK(file_->Write(reinterpret_cast<const uint8_t*>(data), 8));
+ ASSERT_OK(file_->Write(data, 8));
ASSERT_OK(file_->Tell(&position));
ASSERT_EQ(8, position);
}
@@ -179,7 +179,7 @@ TEST_F(TestFileOutputStream, TruncatesNewFile) {
ASSERT_OK(FileOutputStream::Open(path_, &file_));
const char* data = "testdata";
- ASSERT_OK(file_->Write(reinterpret_cast<const uint8_t*>(data),
strlen(data)));
+ ASSERT_OK(file_->Write(data, strlen(data)));
ASSERT_OK(file_->Close());
ASSERT_OK(FileOutputStream::Open(path_, &file_));
@@ -583,8 +583,7 @@ TEST_F(TestMemoryMappedFile, ThreadSafety) {
std::shared_ptr<MemoryMappedFile> file;
ASSERT_OK(MemoryMappedFile::Open(path, FileMode::READWRITE, &file));
- ASSERT_OK(file->Write(reinterpret_cast<const uint8_t*>(data.c_str()),
- static_cast<int64_t>(data.size())));
+ ASSERT_OK(file->Write(data.c_str(), static_cast<int64_t>(data.size())));
std::atomic<int> correct_count(0);
constexpr int niter = 10000;
diff --git a/cpp/src/arrow/io/io-memory-test.cc
b/cpp/src/arrow/io/io-memory-test.cc
index 117972f1c..8c2e8c3b0 100644
--- a/cpp/src/arrow/io/io-memory-test.cc
+++ b/cpp/src/arrow/io/io-memory-test.cc
@@ -93,7 +93,7 @@ TEST(TestFixedSizeBufferWriter, Basics) {
std::string data = "data123456";
auto nbytes = static_cast<int64_t>(data.size());
- ASSERT_OK(writer.Write(reinterpret_cast<const uint8_t*>(data.c_str()),
nbytes));
+ ASSERT_OK(writer.Write(data.c_str(), nbytes));
ASSERT_OK(writer.Tell(&position));
ASSERT_EQ(nbytes, position);
diff --git a/cpp/src/arrow/io/memory.cc b/cpp/src/arrow/io/memory.cc
index d9c84b495..74ec85c0e 100644
--- a/cpp/src/arrow/io/memory.cc
+++ b/cpp/src/arrow/io/memory.cc
@@ -79,7 +79,7 @@ Status BufferOutputStream::Tell(int64_t* position) const {
return Status::OK();
}
-Status BufferOutputStream::Write(const uint8_t* data, int64_t nbytes) {
+Status BufferOutputStream::Write(const void* data, int64_t nbytes) {
if (ARROW_PREDICT_FALSE(!is_open_)) {
return Status::IOError("OutputStream is closed");
}
@@ -116,7 +116,7 @@ Status MockOutputStream::Tell(int64_t* position) const {
return Status::OK();
}
-Status MockOutputStream::Write(const uint8_t* data, int64_t nbytes) {
+Status MockOutputStream::Write(const void* data, int64_t nbytes) {
extent_bytes_written_ += nbytes;
return Status::OK();
}
@@ -162,9 +162,10 @@ class FixedSizeBufferWriter::FixedSizeBufferWriterImpl {
return Status::OK();
}
- Status Write(const uint8_t* data, int64_t nbytes) {
+ Status Write(const void* data, int64_t nbytes) {
if (nbytes > memcopy_threshold_ && memcopy_num_threads_ > 1) {
- internal::parallel_memcopy(mutable_data_ + position_, data, nbytes,
+ internal::parallel_memcopy(mutable_data_ + position_,
+ reinterpret_cast<const uint8_t*>(data),
nbytes,
memcopy_blocksize_, memcopy_num_threads_);
} else {
memcpy(mutable_data_ + position_, data, nbytes);
@@ -173,7 +174,7 @@ class FixedSizeBufferWriter::FixedSizeBufferWriterImpl {
return Status::OK();
}
- Status WriteAt(int64_t position, const uint8_t* data, int64_t nbytes) {
+ Status WriteAt(int64_t position, const void* data, int64_t nbytes) {
std::lock_guard<std::mutex> guard(lock_);
RETURN_NOT_OK(Seek(position));
return Write(data, nbytes);
@@ -210,11 +211,11 @@ Status FixedSizeBufferWriter::Tell(int64_t* position)
const {
return impl_->Tell(position);
}
-Status FixedSizeBufferWriter::Write(const uint8_t* data, int64_t nbytes) {
+Status FixedSizeBufferWriter::Write(const void* data, int64_t nbytes) {
return impl_->Write(data, nbytes);
}
-Status FixedSizeBufferWriter::WriteAt(int64_t position, const uint8_t* data,
+Status FixedSizeBufferWriter::WriteAt(int64_t position, const void* data,
int64_t nbytes) {
return impl_->WriteAt(position, data, nbytes);
}
@@ -252,7 +253,7 @@ Status BufferReader::Tell(int64_t* position) const {
bool BufferReader::supports_zero_copy() const { return true; }
-Status BufferReader::Read(int64_t nbytes, int64_t* bytes_read, uint8_t*
buffer) {
+Status BufferReader::Read(int64_t nbytes, int64_t* bytes_read, void* buffer) {
memcpy(buffer, data_ + position_, nbytes);
*bytes_read = std::min(nbytes, size_ - position_);
position_ += *bytes_read;
@@ -273,7 +274,7 @@ Status BufferReader::Read(int64_t nbytes,
std::shared_ptr<Buffer>* out) {
}
Status BufferReader::ReadAt(int64_t position, int64_t nbytes, int64_t*
bytes_read,
- uint8_t* out) {
+ void* out) {
return RandomAccessFile::ReadAt(position, nbytes, bytes_read, out);
}
diff --git a/cpp/src/arrow/io/memory.h b/cpp/src/arrow/io/memory.h
index 3aec91f72..8dfd582f9 100644
--- a/cpp/src/arrow/io/memory.h
+++ b/cpp/src/arrow/io/memory.h
@@ -48,7 +48,7 @@ class ARROW_EXPORT BufferOutputStream : public OutputStream {
// Implement the OutputStream interface
Status Close() override;
Status Tell(int64_t* position) const override;
- Status Write(const uint8_t* data, int64_t nbytes) override;
+ Status Write(const void* data, int64_t nbytes) override;
/// Close the stream and return the buffer
Status Finish(std::shared_ptr<Buffer>* result);
@@ -72,7 +72,7 @@ class ARROW_EXPORT MockOutputStream : public OutputStream {
// Implement the OutputStream interface
Status Close() override;
Status Tell(int64_t* position) const override;
- Status Write(const uint8_t* data, int64_t nbytes) override;
+ Status Write(const void* data, int64_t nbytes) override;
int64_t GetExtentBytesWritten() const { return extent_bytes_written_; }
@@ -90,8 +90,8 @@ class ARROW_EXPORT FixedSizeBufferWriter : public
WriteableFile {
Status Close() override;
Status Seek(int64_t position) override;
Status Tell(int64_t* position) const override;
- Status Write(const uint8_t* data, int64_t nbytes) override;
- Status WriteAt(int64_t position, const uint8_t* data, int64_t nbytes)
override;
+ Status Write(const void* data, int64_t nbytes) override;
+ Status WriteAt(int64_t position, const void* data, int64_t nbytes) override;
void set_memcopy_threads(int num_threads);
void set_memcopy_blocksize(int64_t blocksize);
@@ -111,12 +111,12 @@ class ARROW_EXPORT BufferReader : public RandomAccessFile
{
Status Close() override;
Status Tell(int64_t* position) const override;
- Status Read(int64_t nbytes, int64_t* bytes_read, uint8_t* buffer) override;
+ Status Read(int64_t nbytes, int64_t* bytes_read, void* buffer) override;
// Zero copy read
Status Read(int64_t nbytes, std::shared_ptr<Buffer>* out) override;
Status ReadAt(int64_t position, int64_t nbytes, int64_t* bytes_read,
- uint8_t* out) override;
+ void* out) override;
/// Default implementation is thread-safe
Status ReadAt(int64_t position, int64_t nbytes, std::shared_ptr<Buffer>*
out) override;
diff --git a/cpp/src/arrow/ipc/feather.cc b/cpp/src/arrow/ipc/feather.cc
index d339449c0..d3872503e 100644
--- a/cpp/src/arrow/ipc/feather.cc
+++ b/cpp/src/arrow/ipc/feather.cc
@@ -523,10 +523,8 @@ class TableWriter::TableWriterImpl : public ArrayVisitor {
uint32_t buffer_size = static_cast<uint32_t>(bytes_written);
// Footer: metadata length, magic bytes
- RETURN_NOT_OK(
- stream_->Write(reinterpret_cast<const uint8_t*>(&buffer_size),
sizeof(uint32_t)));
- return stream_->Write(reinterpret_cast<const uint8_t*>(kFeatherMagicBytes),
- strlen(kFeatherMagicBytes));
+ RETURN_NOT_OK(stream_->Write(&buffer_size, sizeof(uint32_t)));
+ return stream_->Write(kFeatherMagicBytes, strlen(kFeatherMagicBytes));
}
Status LoadArrayMetadata(const Array& values, ArrayMetadata* meta) {
diff --git a/cpp/src/arrow/ipc/json-integration-test.cc
b/cpp/src/arrow/ipc/json-integration-test.cc
index f487487df..f362d9701 100644
--- a/cpp/src/arrow/ipc/json-integration-test.cc
+++ b/cpp/src/arrow/ipc/json-integration-test.cc
@@ -119,8 +119,7 @@ static Status ConvertArrowToJson(const std::string&
arrow_path,
std::string result;
RETURN_NOT_OK(writer->Finish(&result));
- return out_file->Write(reinterpret_cast<const uint8_t*>(result.c_str()),
- static_cast<int64_t>(result.size()));
+ return out_file->Write(result.c_str(), static_cast<int64_t>(result.size()));
}
static Status ValidateArrowVsJson(const std::string& arrow_path,
@@ -250,8 +249,7 @@ class TestJSONIntegration : public ::testing::Test {
do {
std::shared_ptr<io::FileOutputStream> out;
RETURN_NOT_OK(io::FileOutputStream::Open(path, &out));
- RETURN_NOT_OK(out->Write(reinterpret_cast<const uint8_t*>(data),
- static_cast<int64_t>(strlen(data))));
+ RETURN_NOT_OK(out->Write(data, static_cast<int64_t>(strlen(data))));
} while (0);
return Status::OK();
}
diff --git a/cpp/src/arrow/ipc/metadata-internal.cc
b/cpp/src/arrow/ipc/metadata-internal.cc
index 87b4708bf..05202ea93 100644
--- a/cpp/src/arrow/ipc/metadata-internal.cc
+++ b/cpp/src/arrow/ipc/metadata-internal.cc
@@ -945,8 +945,7 @@ Status WriteMessage(const Buffer& message,
io::OutputStream* file,
// Write the flatbuffer size prefix including padding
int32_t flatbuffer_size = padded_message_length - 4;
- RETURN_NOT_OK(
- file->Write(reinterpret_cast<const uint8_t*>(&flatbuffer_size),
sizeof(int32_t)));
+ RETURN_NOT_OK(file->Write(&flatbuffer_size, sizeof(int32_t)));
// Write the flatbuffer
RETURN_NOT_OK(file->Write(message.data(), message.size()));
diff --git a/cpp/src/arrow/ipc/writer.cc b/cpp/src/arrow/ipc/writer.cc
index 3c1db0615..13daf2be8 100644
--- a/cpp/src/arrow/ipc/writer.cc
+++ b/cpp/src/arrow/ipc/writer.cc
@@ -687,7 +687,7 @@ class StreamBookKeeper {
}
// Write data and update position
- Status Write(const uint8_t* data, int64_t nbytes) {
+ Status Write(const void* data, int64_t nbytes) {
RETURN_NOT_OK(sink_->Write(data, nbytes));
position_ += nbytes;
return Status::OK();
@@ -776,7 +776,7 @@ class RecordBatchStreamWriter::RecordBatchStreamWriterImpl
: public StreamBookKe
// Write 0 EOS message
const int32_t kEos = 0;
- return Write(reinterpret_cast<const uint8_t*>(&kEos), sizeof(int32_t));
+ return Write(&kEos, sizeof(int32_t));
}
Status CheckStarted() {
@@ -864,8 +864,7 @@ class RecordBatchFileWriter::RecordBatchFileWriterImpl
Status Start() override {
// It is only necessary to align to 8-byte boundary at the start of the
file
- RETURN_NOT_OK(Write(reinterpret_cast<const uint8_t*>(kArrowMagicBytes),
- strlen(kArrowMagicBytes)));
+ RETURN_NOT_OK(Write(kArrowMagicBytes, strlen(kArrowMagicBytes)));
RETURN_NOT_OK(Align());
// We write the schema at the start of the file (and the end). This also
@@ -889,12 +888,10 @@ class RecordBatchFileWriter::RecordBatchFileWriterImpl
return Status::Invalid("Invalid file footer");
}
- RETURN_NOT_OK(
- Write(reinterpret_cast<const uint8_t*>(&footer_length),
sizeof(int32_t)));
+ RETURN_NOT_OK(Write(&footer_length, sizeof(int32_t)));
// Write magic bytes to end file
- return Write(reinterpret_cast<const uint8_t*>(kArrowMagicBytes),
- strlen(kArrowMagicBytes));
+ return Write(kArrowMagicBytes, strlen(kArrowMagicBytes));
}
};
diff --git a/cpp/src/arrow/python/io.cc b/cpp/src/arrow/python/io.cc
index b01358ab0..cc3892928 100644
--- a/cpp/src/arrow/python/io.cc
+++ b/cpp/src/arrow/python/io.cc
@@ -76,7 +76,7 @@ class PythonFile {
return Status::OK();
}
- Status Write(const uint8_t* data, int64_t nbytes) {
+ Status Write(const void* data, int64_t nbytes) {
PyObject* py_data =
PyBytes_FromStringAndSize(reinterpret_cast<const char*>(data), nbytes);
PY_RETURN_IF_ERROR(StatusCode::IOError);
@@ -130,7 +130,7 @@ Status PyReadableFile::Tell(int64_t* position) const {
return file_->Tell(position);
}
-Status PyReadableFile::Read(int64_t nbytes, int64_t* bytes_read, uint8_t* out)
{
+Status PyReadableFile::Read(int64_t nbytes, int64_t* bytes_read, void* out) {
PyAcquireGIL lock;
PyObject* bytes_obj;
ARROW_RETURN_NOT_OK(file_->Read(nbytes, &bytes_obj));
@@ -155,7 +155,7 @@ Status PyReadableFile::Read(int64_t nbytes,
std::shared_ptr<Buffer>* out) {
}
Status PyReadableFile::ReadAt(int64_t position, int64_t nbytes, int64_t*
bytes_read,
- uint8_t* out) {
+ void* out) {
std::lock_guard<std::mutex> guard(file_->lock());
RETURN_NOT_OK(Seek(position));
return Read(nbytes, bytes_read, out);
@@ -208,7 +208,7 @@ Status PyOutputStream::Tell(int64_t* position) const {
return Status::OK();
}
-Status PyOutputStream::Write(const uint8_t* data, int64_t nbytes) {
+Status PyOutputStream::Write(const void* data, int64_t nbytes) {
PyAcquireGIL lock;
position_ += nbytes;
return file_->Write(data, nbytes);
diff --git a/cpp/src/arrow/python/io.h b/cpp/src/arrow/python/io.h
index bf5db5313..f550de7b2 100644
--- a/cpp/src/arrow/python/io.h
+++ b/cpp/src/arrow/python/io.h
@@ -41,12 +41,12 @@ class ARROW_EXPORT PyReadableFile : public
io::RandomAccessFile {
Status Close() override;
- Status Read(int64_t nbytes, int64_t* bytes_read, uint8_t* out) override;
+ Status Read(int64_t nbytes, int64_t* bytes_read, void* out) override;
Status Read(int64_t nbytes, std::shared_ptr<Buffer>* out) override;
// Thread-safe version
Status ReadAt(int64_t position, int64_t nbytes, int64_t* bytes_read,
- uint8_t* out) override;
+ void* out) override;
// Thread-safe version
Status ReadAt(int64_t position, int64_t nbytes, std::shared_ptr<Buffer>*
out) override;
@@ -70,7 +70,7 @@ class ARROW_EXPORT PyOutputStream : public io::OutputStream {
Status Close() override;
Status Tell(int64_t* position) const override;
- Status Write(const uint8_t* data, int64_t nbytes) override;
+ Status Write(const void* data, int64_t nbytes) override;
private:
std::unique_ptr<PythonFile> file_;
diff --git a/cpp/src/arrow/util/io-util.h b/cpp/src/arrow/util/io-util.h
index dbca0d8be..7e2a94ca8 100644
--- a/cpp/src/arrow/util/io-util.h
+++ b/cpp/src/arrow/util/io-util.h
@@ -40,7 +40,7 @@ class StdoutStream : public OutputStream {
return Status::OK();
}
- Status Write(const uint8_t* data, int64_t nbytes) override {
+ Status Write(const void* data, int64_t nbytes) override {
pos_ += nbytes;
std::cout.write(reinterpret_cast<const char*>(data), nbytes);
return Status::OK();
@@ -63,7 +63,7 @@ class StdinStream : public InputStream {
return Status::OK();
}
- Status Read(int64_t nbytes, int64_t* bytes_read, uint8_t* out) override {
+ Status Read(int64_t nbytes, int64_t* bytes_read, void* out) override {
std::cin.read(reinterpret_cast<char*>(out), nbytes);
if (std::cin) {
*bytes_read = nbytes;
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
[email protected]
> [C++] Use const void* in Writable::Write instead of const uint8_t*
> ------------------------------------------------------------------
>
> Key: ARROW-1850
> URL: https://issues.apache.org/jira/browse/ARROW-1850
> Project: Apache Arrow
> Issue Type: Improvement
> Components: C++
> Reporter: Wes McKinney
> Assignee: Wes McKinney
> Labels: pull-request-available
> Fix For: 0.8.0
>
> Attachments: text.html
>
>
> I noticed that {{Writable}} is also misspelled. This would spare the user
> many usages of {{reinterpret_cast<const uint8_t*>(...)}}, and also will not
> cause any explicit API breakage (except where users have overridden the
> virtual function)
--
This message was sent by Atlassian JIRA
(v6.4.14#64029)
