ARROW-8224: [C++] Remove APIs deprecated prior to 0.16.0

Closes #6735 from wesm/ARROW-8224 Authored-by: Wes McKinney <wesm+git@apache.org> Signed-off-by: Wes McKinney <wesm+git@apache.org>
apache · Mar 27, 2020 · 4e680c4 · 4e680c4
1 parent 6981cf8
commit 4e680c4
Show file tree

Hide file tree

Showing 28 changed files with 53 additions and 614 deletions.
diff --git a/cpp/src/arrow/array.h b/cpp/src/arrow/array.h
@@ -1224,12 +1224,6 @@ class ARROW_EXPORT UnionArray : public Array {
 
   const type_code_t* raw_type_codes() const { return raw_type_codes_ + data_->offset; }
 
-  ARROW_DEPRECATED("Use UnionArray::type_codes")
-  std::shared_ptr<Buffer> type_ids() const { return type_codes(); }
-
-  ARROW_DEPRECATED("Use UnionArray::raw_type_codes")
-  const type_code_t* raw_type_ids() const { return raw_type_codes(); }
-
   /// The physical child id containing value at index.
   int child_id(int64_t i) const {
     return union_type_->child_ids()[raw_type_codes_[i + data_->offset]];

diff --git a/cpp/src/arrow/csv/reader.cc b/cpp/src/arrow/csv/reader.cc
@@ -504,19 +504,5 @@ Result<std::shared_ptr<TableReader>> TableReader::Make(
   return reader;
 }
 
-/////////////////////////////////////////////////////////////////////////
-// Deprecated API(s)
-
-Status TableReader::Make(MemoryPool* pool, std::shared_ptr<io::InputStream> input,
-                         const ReadOptions& read_options,
-                         const ParseOptions& parse_options,
-                         const ConvertOptions& convert_options,
-                         std::shared_ptr<TableReader>* out) {
-  return Make(pool, std::move(input), read_options, parse_options, convert_options)
-      .Value(out);
-}
-
-Status TableReader::Read(std::shared_ptr<Table>* out) { return Read().Value(out); }
-
 }  // namespace csv
 }  // namespace arrow
diff --git a/cpp/src/arrow/csv/reader.h b/cpp/src/arrow/csv/reader.h
@@ -39,20 +39,12 @@ class ARROW_EXPORT TableReader {
   /// Read the entire CSV file and convert it to a Arrow Table
   virtual Result<std::shared_ptr<Table>> Read() = 0;
 
-  ARROW_DEPRECATED("Use Result-returning overload")
-  virtual Status Read(std::shared_ptr<Table>* out);
-
   /// Create a TableReader instance
   static Result<std::shared_ptr<TableReader>> Make(MemoryPool* pool,
                                                    std::shared_ptr<io::InputStream> input,
                                                    const ReadOptions&,
                                                    const ParseOptions&,
                                                    const ConvertOptions&);
-
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Make(MemoryPool* pool, std::shared_ptr<io::InputStream> input,
-                     const ReadOptions&, const ParseOptions&, const ConvertOptions&,
-                     std::shared_ptr<TableReader>* out);
 };
 
 }  // namespace csv

diff --git a/cpp/src/arrow/io/buffered.cc b/cpp/src/arrow/io/buffered.cc
@@ -209,12 +209,6 @@ Result<std::shared_ptr<BufferedOutputStream>> BufferedOutputStream::Create(
   return result;
 }
 
-Status BufferedOutputStream::Create(int64_t buffer_size, MemoryPool* pool,
-                                    std::shared_ptr<OutputStream> raw,
-                                    std::shared_ptr<BufferedOutputStream>* out) {
-  return Create(buffer_size, pool, std::move(raw)).Value(out);
-}
-
 BufferedOutputStream::~BufferedOutputStream() { internal::CloseFromDestructor(this); }
 
 Status BufferedOutputStream::SetBufferSize(int64_t new_buffer_size) {
@@ -229,10 +223,6 @@ Result<std::shared_ptr<OutputStream>> BufferedOutputStream::Detach() {
   return impl_->Detach();
 }
 
-Status BufferedOutputStream::Detach(std::shared_ptr<OutputStream>* raw) {
-  return Detach().Value(raw);
-}
-
 Status BufferedOutputStream::Close() { return impl_->Close(); }
 
 Status BufferedOutputStream::Abort() { return impl_->Abort(); }
@@ -453,13 +443,6 @@ Result<std::shared_ptr<BufferedInputStream>> BufferedInputStream::Create(
   return result;
 }
 
-Status BufferedInputStream::Create(int64_t buffer_size, MemoryPool* pool,
-                                   std::shared_ptr<InputStream> raw,
-                                   std::shared_ptr<BufferedInputStream>* out,
-                                   int64_t raw_total_bytes_bound) {
-  return Create(buffer_size, pool, std::move(raw)).Value(out);
-}
-
 Status BufferedInputStream::DoClose() { return impl_->Close(); }
 
 Status BufferedInputStream::DoAbort() { return impl_->Abort(); }

diff --git a/cpp/src/arrow/io/buffered.h b/cpp/src/arrow/io/buffered.h
@@ -47,11 +47,6 @@ class ARROW_EXPORT BufferedOutputStream : public OutputStream {
   static Result<std::shared_ptr<BufferedOutputStream>> Create(
       int64_t buffer_size, MemoryPool* pool, std::shared_ptr<OutputStream> raw);
 
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Create(int64_t buffer_size, MemoryPool* pool,
-                       std::shared_ptr<OutputStream> raw,
-                       std::shared_ptr<BufferedOutputStream>* out);
-
   /// \brief Resize internal buffer
   /// \param[in] new_buffer_size the new buffer size
   /// \return Status
@@ -69,9 +64,6 @@ class ARROW_EXPORT BufferedOutputStream : public OutputStream {
   /// \return the underlying OutputStream
   Result<std::shared_ptr<OutputStream>> Detach();
 
-  ARROW_DEPRECATED("Use Result-returning overload")
-  Status Detach(std::shared_ptr<OutputStream>* raw);
-
   // OutputStream interface
 
   /// \brief Close the buffered output stream.  This implicitly closes the
@@ -118,12 +110,6 @@ class ARROW_EXPORT BufferedInputStream
       int64_t buffer_size, MemoryPool* pool, std::shared_ptr<InputStream> raw,
       int64_t raw_read_bound = -1);
 
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Create(int64_t buffer_size, MemoryPool* pool,
-                       std::shared_ptr<InputStream> raw,
-                       std::shared_ptr<BufferedInputStream>* out,
-                       int64_t raw_read_bound = -1);
-
   /// \brief Resize internal read buffer; calls to Read(...) will read at least
   /// \param[in] new_buffer_size the new read buffer size
   /// \return Status

diff --git a/cpp/src/arrow/io/compressed.cc b/cpp/src/arrow/io/compressed.cc
@@ -206,18 +206,6 @@ Result<std::shared_ptr<CompressedOutputStream>> CompressedOutputStream::Make(
   return res;
 }
 
-Status CompressedOutputStream::Make(util::Codec* codec,
-                                    const std::shared_ptr<OutputStream>& raw,
-                                    std::shared_ptr<CompressedOutputStream>* out) {
-  return Make(codec, raw).Value(out);
-}
-
-Status CompressedOutputStream::Make(MemoryPool* pool, util::Codec* codec,
-                                    const std::shared_ptr<OutputStream>& raw,
-                                    std::shared_ptr<CompressedOutputStream>* out) {
-  return Make(codec, raw, pool).Value(out);
-}
-
 CompressedOutputStream::~CompressedOutputStream() { internal::CloseFromDestructor(this); }
 
 Status CompressedOutputStream::Close() { return impl_->Close(); }
@@ -429,17 +417,6 @@ Result<std::shared_ptr<CompressedInputStream>> CompressedInputStream::Make(
   return Status::OK();
 }
 
-Status CompressedInputStream::Make(Codec* codec, const std::shared_ptr<InputStream>& raw,
-                                   std::shared_ptr<CompressedInputStream>* out) {
-  return Make(codec, raw).Value(out);
-}
-
-Status CompressedInputStream::Make(MemoryPool* pool, Codec* codec,
-                                   const std::shared_ptr<InputStream>& raw,
-                                   std::shared_ptr<CompressedInputStream>* out) {
-  return Make(codec, raw, pool).Value(out);
-}
-
 CompressedInputStream::~CompressedInputStream() { internal::CloseFromDestructor(this); }
 
 Status CompressedInputStream::DoClose() { return impl_->Close(); }

diff --git a/cpp/src/arrow/io/compressed.h b/cpp/src/arrow/io/compressed.h
@@ -48,14 +48,6 @@ class ARROW_EXPORT CompressedOutputStream : public OutputStream {
       util::Codec* codec, const std::shared_ptr<OutputStream>& raw,
       MemoryPool* pool = default_memory_pool());
 
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Make(util::Codec* codec, const std::shared_ptr<OutputStream>& raw,
-                     std::shared_ptr<CompressedOutputStream>* out);
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Make(MemoryPool* pool, util::Codec* codec,
-                     const std::shared_ptr<OutputStream>& raw,
-                     std::shared_ptr<CompressedOutputStream>* out);
-
   // OutputStream interface
 
   /// \brief Close the compressed output stream.  This implicitly closes the
@@ -94,14 +86,6 @@ class ARROW_EXPORT CompressedInputStream
       util::Codec* codec, const std::shared_ptr<InputStream>& raw,
       MemoryPool* pool = default_memory_pool());
 
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Make(util::Codec* codec, const std::shared_ptr<InputStream>& raw,
-                     std::shared_ptr<CompressedInputStream>* out);
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Make(MemoryPool* pool, util::Codec* codec,
-                     const std::shared_ptr<InputStream>& raw,
-                     std::shared_ptr<CompressedInputStream>* out);
-
   // InputStream interface
 
   bool closed() const override;

diff --git a/cpp/src/arrow/io/file.cc b/cpp/src/arrow/io/file.cc
@@ -285,23 +285,6 @@ Result<std::shared_ptr<ReadableFile>> ReadableFile::Open(int fd, MemoryPool* poo
   return file;
 }
 
-Status ReadableFile::Open(const std::string& path, std::shared_ptr<ReadableFile>* file) {
-  return Open(path).Value(file);
-}
-
-Status ReadableFile::Open(const std::string& path, MemoryPool* pool,
-                          std::shared_ptr<ReadableFile>* file) {
-  return Open(path, pool).Value(file);
-}
-
-Status ReadableFile::Open(int fd, std::shared_ptr<ReadableFile>* file) {
-  return Open(fd).Value(file);
-}
-
-Status ReadableFile::Open(int fd, MemoryPool* pool, std::shared_ptr<ReadableFile>* file) {
-  return Open(fd, pool).Value(file);
-}
-
 Status ReadableFile::DoClose() { return impl_->Close(); }
 
 bool ReadableFile::closed() const { return !impl_->is_open(); }
@@ -359,34 +342,6 @@ Result<std::shared_ptr<FileOutputStream>> FileOutputStream::Open(int fd) {
   return stream;
 }
 
-Status FileOutputStream::Open(const std::string& path,
-                              std::shared_ptr<OutputStream>* out) {
-  return Open(path, false).Value(out);
-}
-
-Status FileOutputStream::Open(const std::string& path, bool append,
-                              std::shared_ptr<OutputStream>* out) {
-  return Open(path, append).Value(out);
-}
-
-Status FileOutputStream::Open(int fd, std::shared_ptr<OutputStream>* out) {
-  return Open(fd).Value(out);
-}
-
-Status FileOutputStream::Open(const std::string& path,
-                              std::shared_ptr<FileOutputStream>* out) {
-  return Open(path, false).Value(out);
-}
-
-Status FileOutputStream::Open(const std::string& path, bool append,
-                              std::shared_ptr<FileOutputStream>* out) {
-  return Open(path, append).Value(out);
-}
-
-Status FileOutputStream::Open(int fd, std::shared_ptr<FileOutputStream>* out) {
-  return Open(fd).Value(out);
-}
-
 Status FileOutputStream::Close() { return impl_->Close(); }
 
 bool FileOutputStream::closed() const { return !impl_->is_open(); }
@@ -632,11 +587,6 @@ Result<std::shared_ptr<MemoryMappedFile>> MemoryMappedFile::Create(
   return MemoryMappedFile::Open(path, FileMode::READWRITE);
 }
 
-Status MemoryMappedFile::Create(const std::string& path, int64_t size,
-                                std::shared_ptr<MemoryMappedFile>* out) {
-  return Create(path, size).Value(out);
-}
-
 Result<std::shared_ptr<MemoryMappedFile>> MemoryMappedFile::Open(const std::string& path,
                                                                  FileMode::type mode) {
   std::shared_ptr<MemoryMappedFile> result(new MemoryMappedFile());
@@ -657,17 +607,6 @@ Result<std::shared_ptr<MemoryMappedFile>> MemoryMappedFile::Open(const std::stri
   return result;
 }
 
-Status MemoryMappedFile::Open(const std::string& path, FileMode::type mode,
-                              std::shared_ptr<MemoryMappedFile>* out) {
-  return Open(path, mode).Value(out);
-}
-
-Status MemoryMappedFile::Open(const std::string& path, FileMode::type mode,
-                              const int64_t offset, const int64_t length,
-                              std::shared_ptr<MemoryMappedFile>* out) {
-  return Open(path, mode, offset, length).Value(out);
-}
-
 Result<int64_t> MemoryMappedFile::GetSize() {
   RETURN_NOT_OK(memory_map_->CheckClosed());
   return memory_map_->size();

diff --git a/cpp/src/arrow/io/file.h b/cpp/src/arrow/io/file.h
@@ -50,17 +50,6 @@ class ARROW_EXPORT FileOutputStream : public OutputStream {
   static Result<std::shared_ptr<FileOutputStream>> Open(const std::string& path,
                                                         bool append = false);
 
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Open(const std::string& path, std::shared_ptr<OutputStream>* out);
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Open(const std::string& path, bool append,
-                     std::shared_ptr<OutputStream>* out);
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Open(const std::string& path, std::shared_ptr<FileOutputStream>* file);
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Open(const std::string& path, bool append,
-                     std::shared_ptr<FileOutputStream>* file);
-
   /// \brief Open a file descriptor for writing.  The underlying file isn't
   /// truncated.
   /// \param[in] fd file descriptor
@@ -70,11 +59,6 @@ class ARROW_EXPORT FileOutputStream : public OutputStream {
   /// on Close() or destruction.
   static Result<std::shared_ptr<FileOutputStream>> Open(int fd);
 
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Open(int fd, std::shared_ptr<OutputStream>* out);
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Open(int fd, std::shared_ptr<FileOutputStream>* out);
-
   // OutputStream interface
   Status Close() override;
   bool closed() const override;
@@ -112,12 +96,6 @@ class ARROW_EXPORT ReadableFile
   static Result<std::shared_ptr<ReadableFile>> Open(
       const std::string& path, MemoryPool* pool = default_memory_pool());
 
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Open(const std::string& path, std::shared_ptr<ReadableFile>* file);
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Open(const std::string& path, MemoryPool* pool,
-                     std::shared_ptr<ReadableFile>* file);
-
   /// \brief Open a local file for reading
   /// \param[in] fd file descriptor
   /// \param[in] pool a MemoryPool for memory allocations
@@ -128,11 +106,6 @@ class ARROW_EXPORT ReadableFile
   static Result<std::shared_ptr<ReadableFile>> Open(
       int fd, MemoryPool* pool = default_memory_pool());
 
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Open(int fd, std::shared_ptr<ReadableFile>* file);
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Open(int fd, MemoryPool* pool, std::shared_ptr<ReadableFile>* file);
-
   bool closed() const override;
 
   int file_descriptor() const;
@@ -175,28 +148,16 @@ class ARROW_EXPORT MemoryMappedFile : public ReadWriteFileInterface {
   static Result<std::shared_ptr<MemoryMappedFile>> Create(const std::string& path,
                                                           int64_t size);
 
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Create(const std::string& path, int64_t size,
-                       std::shared_ptr<MemoryMappedFile>* out);
-
   // mmap() with whole file
   static Result<std::shared_ptr<MemoryMappedFile>> Open(const std::string& path,
                                                         FileMode::type mode);
 
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Open(const std::string& path, FileMode::type mode,
-                     std::shared_ptr<MemoryMappedFile>* out);
-
   // mmap() with a region of file, the offset must be a multiple of the page size
   static Result<std::shared_ptr<MemoryMappedFile>> Open(const std::string& path,
                                                         FileMode::type mode,
                                                         const int64_t offset,
                                                         const int64_t length);
 
-  ARROW_DEPRECATED("Use Result-returning overload")
-  static Status Open(const std::string& path, FileMode::type mode, const int64_t offset,
-                     const int64_t length, std::shared_ptr<MemoryMappedFile>* out);
-
   Status Close() override;
 
   bool closed() const override;

diff --git a/cpp/src/arrow/io/hdfs.cc b/cpp/src/arrow/io/hdfs.cc
@@ -648,20 +648,6 @@ Status HadoopFileSystem::Rename(const std::string& src, const std::string& dst)
   return impl_->Rename(src, dst);
 }
 
-// Deprecated in 0.11
-
-Status HadoopFileSystem::OpenWriteable(const std::string& path, bool append,
-                                       int32_t buffer_size, int16_t replication,
-                                       int64_t default_block_size,
-                                       std::shared_ptr<HdfsOutputStream>* file) {
-  return OpenWritable(path, append, buffer_size, replication, default_block_size, file);
-}
-
-Status HadoopFileSystem::OpenWriteable(const std::string& path, bool append,
-                                       std::shared_ptr<HdfsOutputStream>* file) {
-  return OpenWritable(path, append, 0, 0, 0, file);
-}
-
 // ----------------------------------------------------------------------
 // Allow public API users to check whether we are set up correctly