Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 0 additions & 6 deletions cpp/src/arrow/array.h
Original file line number Diff line number Diff line change
Expand Up @@ -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]];
Expand Down
14 changes: 0 additions & 14 deletions cpp/src/arrow/csv/reader.cc
Original file line number Diff line number Diff line change
Expand Up @@ -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
8 changes: 0 additions & 8 deletions cpp/src/arrow/csv/reader.h
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
17 changes: 0 additions & 17 deletions cpp/src/arrow/io/buffered.cc
Original file line number Diff line number Diff line change
Expand Up @@ -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) {
Expand All @@ -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(); }
Expand Down Expand Up @@ -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(); }
Expand Down
14 changes: 0 additions & 14 deletions cpp/src/arrow/io/buffered.h
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand All @@ -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
Expand Down Expand Up @@ -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
Expand Down
23 changes: 0 additions & 23 deletions cpp/src/arrow/io/compressed.cc
Original file line number Diff line number Diff line change
Expand Up @@ -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(); }
Expand Down Expand Up @@ -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(); }
Expand Down
16 changes: 0 additions & 16 deletions cpp/src/arrow/io/compressed.h
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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;
Expand Down
61 changes: 0 additions & 61 deletions cpp/src/arrow/io/file.cc
Original file line number Diff line number Diff line change
Expand Up @@ -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(); }
Expand Down Expand Up @@ -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(); }
Expand Down Expand Up @@ -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());
Expand All @@ -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();
Expand Down
39 changes: 0 additions & 39 deletions cpp/src/arrow/io/file.h
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand All @@ -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;
Expand Down Expand Up @@ -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
Expand All @@ -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;
Expand Down Expand Up @@ -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;
Expand Down
14 changes: 0 additions & 14 deletions cpp/src/arrow/io/hdfs.cc
Original file line number Diff line number Diff line change
Expand Up @@ -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

Expand Down
Loading