arrow-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From w...@apache.org
Subject [1/2] arrow git commit: ARROW-261: Refactor String/Binary code paths to reflect unnested (non-list-based) structure
Date Mon, 17 Oct 2016 17:44:44 GMT
Repository: arrow
Updated Branches:
  refs/heads/master 8e8b17f99 -> 732a2059d


http://git-wip-us.apache.org/repos/asf/arrow/blob/732a2059/python/src/pyarrow/adapters/pandas.h
----------------------------------------------------------------------
diff --git a/python/src/pyarrow/adapters/pandas.h b/python/src/pyarrow/adapters/pandas.h
index 141d121..532495d 100644
--- a/python/src/pyarrow/adapters/pandas.h
+++ b/python/src/pyarrow/adapters/pandas.h
@@ -32,27 +32,26 @@ namespace arrow {
 class Array;
 class Column;
 class MemoryPool;
+class Status;
 
 } // namespace arrow
 
 namespace pyarrow {
 
-class Status;
-
 PYARROW_EXPORT
-Status ConvertArrayToPandas(const std::shared_ptr<arrow::Array>& arr, PyObject*
py_ref,
-    PyObject** out);
+arrow::Status ConvertArrayToPandas(const std::shared_ptr<arrow::Array>& arr,
+    PyObject* py_ref, PyObject** out);
 
 PYARROW_EXPORT
-Status ConvertColumnToPandas(const std::shared_ptr<arrow::Column>& col, PyObject*
py_ref,
-    PyObject** out);
+arrow::Status ConvertColumnToPandas(const std::shared_ptr<arrow::Column>& col,
+    PyObject* py_ref, PyObject** out);
 
 PYARROW_EXPORT
-Status PandasMaskedToArrow(arrow::MemoryPool* pool, PyObject* ao, PyObject* mo,
+arrow::Status PandasMaskedToArrow(arrow::MemoryPool* pool, PyObject* ao, PyObject* mo,
     std::shared_ptr<arrow::Array>* out);
 
 PYARROW_EXPORT
-Status PandasToArrow(arrow::MemoryPool* pool, PyObject* ao,
+arrow::Status PandasToArrow(arrow::MemoryPool* pool, PyObject* ao,
     std::shared_ptr<arrow::Array>* out);
 
 } // namespace pyarrow

http://git-wip-us.apache.org/repos/asf/arrow/blob/732a2059/python/src/pyarrow/api.h
----------------------------------------------------------------------
diff --git a/python/src/pyarrow/api.h b/python/src/pyarrow/api.h
index 72be6af..6dbbc45 100644
--- a/python/src/pyarrow/api.h
+++ b/python/src/pyarrow/api.h
@@ -18,8 +18,6 @@
 #ifndef PYARROW_API_H
 #define PYARROW_API_H
 
-#include "pyarrow/status.h"
-
 #include "pyarrow/helpers.h"
 
 #include "pyarrow/adapters/builtin.h"

http://git-wip-us.apache.org/repos/asf/arrow/blob/732a2059/python/src/pyarrow/common.cc
----------------------------------------------------------------------
diff --git a/python/src/pyarrow/common.cc b/python/src/pyarrow/common.cc
index 09f3efb..fa875f2 100644
--- a/python/src/pyarrow/common.cc
+++ b/python/src/pyarrow/common.cc
@@ -21,10 +21,10 @@
 #include <mutex>
 #include <sstream>
 
-#include <arrow/util/memory-pool.h>
-#include <arrow/util/status.h>
+#include "arrow/util/memory-pool.h"
+#include "arrow/util/status.h"
 
-#include "pyarrow/status.h"
+using arrow::Status;
 
 namespace pyarrow {
 
@@ -33,18 +33,18 @@ class PyArrowMemoryPool : public arrow::MemoryPool {
   PyArrowMemoryPool() : bytes_allocated_(0) {}
   virtual ~PyArrowMemoryPool() {}
 
-  arrow::Status Allocate(int64_t size, uint8_t** out) override {
+  Status Allocate(int64_t size, uint8_t** out) override {
     std::lock_guard<std::mutex> guard(pool_lock_);
     *out = static_cast<uint8_t*>(std::malloc(size));
     if (*out == nullptr) {
       std::stringstream ss;
       ss << "malloc of size " << size << " failed";
-      return arrow::Status::OutOfMemory(ss.str());
+      return Status::OutOfMemory(ss.str());
     }
 
     bytes_allocated_ += size;
 
-    return arrow::Status::OK();
+    return Status::OK();
   }
 
   int64_t bytes_allocated() const override {

http://git-wip-us.apache.org/repos/asf/arrow/blob/732a2059/python/src/pyarrow/common.h
----------------------------------------------------------------------
diff --git a/python/src/pyarrow/common.h b/python/src/pyarrow/common.h
index 50c2577..7f3131e 100644
--- a/python/src/pyarrow/common.h
+++ b/python/src/pyarrow/common.h
@@ -29,13 +29,6 @@ namespace pyarrow {
 
 #define PYARROW_IS_PY2 PY_MAJOR_VERSION <= 2
 
-#define RETURN_ARROW_NOT_OK(s) do {             \
-    arrow::Status _s = (s);                     \
-    if (!_s.ok()) {                             \
-      return Status::ArrowError(s.ToString());  \
-    }                                           \
-  } while (0);
-
 class OwnedRef {
  public:
   OwnedRef() : obj_(nullptr) {}

http://git-wip-us.apache.org/repos/asf/arrow/blob/732a2059/python/src/pyarrow/io.cc
----------------------------------------------------------------------
diff --git a/python/src/pyarrow/io.cc b/python/src/pyarrow/io.cc
index 7bf32ff..e6dbc12 100644
--- a/python/src/pyarrow/io.cc
+++ b/python/src/pyarrow/io.cc
@@ -20,12 +20,13 @@
 #include <cstdint>
 #include <cstdlib>
 
-#include <arrow/io/memory.h>
-#include <arrow/util/memory-pool.h>
-#include <arrow/util/status.h>
+#include "arrow/io/memory.h"
+#include "arrow/util/memory-pool.h"
+#include "arrow/util/status.h"
 
 #include "pyarrow/common.h"
-#include "pyarrow/status.h"
+
+using arrow::Status;
 
 namespace pyarrow {
 
@@ -41,7 +42,7 @@ PythonFile::~PythonFile() {
   Py_DECREF(file_);
 }
 
-static arrow::Status CheckPyError() {
+static Status CheckPyError() {
   if (PyErr_Occurred()) {
     PyObject *exc_type, *exc_value, *traceback;
     PyErr_Fetch(&exc_type, &exc_value, &traceback);
@@ -51,35 +52,35 @@ static arrow::Status CheckPyError() {
     Py_XDECREF(exc_value);
     Py_XDECREF(traceback);
     PyErr_Clear();
-    return arrow::Status::IOError(message);
+    return Status::IOError(message);
   }
-  return arrow::Status::OK();
+  return Status::OK();
 }
 
-arrow::Status PythonFile::Close() {
+Status PythonFile::Close() {
   // whence: 0 for relative to start of file, 2 for end of file
   PyObject* result = PyObject_CallMethod(file_, "close", "()");
   Py_XDECREF(result);
   ARROW_RETURN_NOT_OK(CheckPyError());
-  return arrow::Status::OK();
+  return Status::OK();
 }
 
-arrow::Status PythonFile::Seek(int64_t position, int whence) {
+Status PythonFile::Seek(int64_t position, int whence) {
   // whence: 0 for relative to start of file, 2 for end of file
   PyObject* result = PyObject_CallMethod(file_, "seek", "(ii)", position, whence);
   Py_XDECREF(result);
   ARROW_RETURN_NOT_OK(CheckPyError());
-  return arrow::Status::OK();
+  return Status::OK();
 }
 
-arrow::Status PythonFile::Read(int64_t nbytes, PyObject** out) {
+Status PythonFile::Read(int64_t nbytes, PyObject** out) {
   PyObject* result = PyObject_CallMethod(file_, "read", "(i)", nbytes);
   ARROW_RETURN_NOT_OK(CheckPyError());
   *out = result;
-  return arrow::Status::OK();
+  return Status::OK();
 }
 
-arrow::Status PythonFile::Write(const uint8_t* data, int64_t nbytes) {
+Status PythonFile::Write(const uint8_t* data, int64_t nbytes) {
   PyObject* py_data = PyBytes_FromStringAndSize(
       reinterpret_cast<const char*>(data), nbytes);
   ARROW_RETURN_NOT_OK(CheckPyError());
@@ -88,10 +89,10 @@ arrow::Status PythonFile::Write(const uint8_t* data, int64_t nbytes) {
   Py_XDECREF(py_data);
   Py_XDECREF(result);
   ARROW_RETURN_NOT_OK(CheckPyError());
-  return arrow::Status::OK();
+  return Status::OK();
 }
 
-arrow::Status PythonFile::Tell(int64_t* position) {
+Status PythonFile::Tell(int64_t* position) {
   PyObject* result = PyObject_CallMethod(file_, "tell", "()");
   ARROW_RETURN_NOT_OK(CheckPyError());
 
@@ -101,7 +102,7 @@ arrow::Status PythonFile::Tell(int64_t* position) {
   // PyLong_AsLongLong can raise OverflowError
   ARROW_RETURN_NOT_OK(CheckPyError());
 
- return arrow::Status::OK();
+ return Status::OK();
 }
 
 // ----------------------------------------------------------------------
@@ -113,22 +114,22 @@ PyReadableFile::PyReadableFile(PyObject* file) {
 
 PyReadableFile::~PyReadableFile() {}
 
-arrow::Status PyReadableFile::Close() {
+Status PyReadableFile::Close() {
   PyGILGuard lock;
   return file_->Close();
 }
 
-arrow::Status PyReadableFile::Seek(int64_t position) {
+Status PyReadableFile::Seek(int64_t position) {
   PyGILGuard lock;
   return file_->Seek(position, 0);
 }
 
-arrow::Status PyReadableFile::Tell(int64_t* position) {
+Status PyReadableFile::Tell(int64_t* position) {
   PyGILGuard lock;
   return file_->Tell(position);
 }
 
-arrow::Status PyReadableFile::Read(int64_t nbytes, int64_t* bytes_read, uint8_t* out) {
+Status PyReadableFile::Read(int64_t nbytes, int64_t* bytes_read, uint8_t* out) {
   PyGILGuard lock;
   PyObject* bytes_obj;
   ARROW_RETURN_NOT_OK(file_->Read(nbytes, &bytes_obj));
@@ -137,10 +138,10 @@ arrow::Status PyReadableFile::Read(int64_t nbytes, int64_t* bytes_read,
uint8_t*
   std::memcpy(out, PyBytes_AS_STRING(bytes_obj), *bytes_read);
   Py_DECREF(bytes_obj);
 
-  return arrow::Status::OK();
+  return Status::OK();
 }
 
-arrow::Status PyReadableFile::Read(int64_t nbytes, std::shared_ptr<arrow::Buffer>*
out) {
+Status PyReadableFile::Read(int64_t nbytes, std::shared_ptr<arrow::Buffer>* out) {
   PyGILGuard lock;
 
   PyObject* bytes_obj;
@@ -149,10 +150,10 @@ arrow::Status PyReadableFile::Read(int64_t nbytes, std::shared_ptr<arrow::Buffer
   *out = std::make_shared<PyBytesBuffer>(bytes_obj);
   Py_DECREF(bytes_obj);
 
-  return arrow::Status::OK();
+  return Status::OK();
 }
 
-arrow::Status PyReadableFile::GetSize(int64_t* size) {
+Status PyReadableFile::GetSize(int64_t* size) {
   PyGILGuard lock;
 
   int64_t current_position;;
@@ -167,7 +168,7 @@ arrow::Status PyReadableFile::GetSize(int64_t* size) {
   ARROW_RETURN_NOT_OK(file_->Seek(current_position, 0));
 
   *size = file_size;
-  return arrow::Status::OK();
+  return Status::OK();
 }
 
 bool PyReadableFile::supports_zero_copy() const {
@@ -183,17 +184,17 @@ PyOutputStream::PyOutputStream(PyObject* file) {
 
 PyOutputStream::~PyOutputStream() {}
 
-arrow::Status PyOutputStream::Close() {
+Status PyOutputStream::Close() {
   PyGILGuard lock;
   return file_->Close();
 }
 
-arrow::Status PyOutputStream::Tell(int64_t* position) {
+Status PyOutputStream::Tell(int64_t* position) {
   PyGILGuard lock;
   return file_->Tell(position);
 }
 
-arrow::Status PyOutputStream::Write(const uint8_t* data, int64_t nbytes) {
+Status PyOutputStream::Write(const uint8_t* data, int64_t nbytes) {
   PyGILGuard lock;
   return file_->Write(data, nbytes);
 }

http://git-wip-us.apache.org/repos/asf/arrow/blob/732a2059/python/src/pyarrow/status.cc
----------------------------------------------------------------------
diff --git a/python/src/pyarrow/status.cc b/python/src/pyarrow/status.cc
deleted file mode 100644
index 1cd54f6..0000000
--- a/python/src/pyarrow/status.cc
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-//
-// A Status encapsulates the result of an operation.  It may indicate success,
-// or it may indicate an error with an associated error message.
-//
-// Multiple threads can invoke const methods on a Status without
-// external synchronization, but if any of the threads may call a
-// non-const method, all threads accessing the same Status must use
-// external synchronization.
-
-#include "pyarrow/status.h"
-
-#include <assert.h>
-#include <cstdint>
-#include <cstring>
-
-namespace pyarrow {
-
-Status::Status(StatusCode code, const std::string& msg, int16_t posix_code) {
-  assert(code != StatusCode::OK);
-  const uint32_t size = msg.size();
-  char* result = new char[size + 7];
-  memcpy(result, &size, sizeof(size));
-  result[4] = static_cast<char>(code);
-  memcpy(result + 5, &posix_code, sizeof(posix_code));
-  memcpy(result + 7, msg.c_str(), msg.size());
-  state_ = result;
-}
-
-const char* Status::CopyState(const char* state) {
-  uint32_t size;
-  memcpy(&size, state, sizeof(size));
-  char* result = new char[size + 7];
-  memcpy(result, state, size + 7);
-  return result;
-}
-
-std::string Status::CodeAsString() const {
-  if (state_ == NULL) {
-    return "OK";
-  }
-
-  const char* type;
-  switch (code()) {
-    case StatusCode::OK:
-      type = "OK";
-      break;
-    case StatusCode::OutOfMemory:
-      type = "Out of memory";
-      break;
-    case StatusCode::KeyError:
-      type = "Key error";
-      break;
-    case StatusCode::TypeError:
-      type = "Value error";
-      break;
-    case StatusCode::ValueError:
-      type = "Value error";
-      break;
-    case StatusCode::IOError:
-      type = "IO error";
-      break;
-    case StatusCode::NotImplemented:
-      type = "Not implemented";
-      break;
-    case StatusCode::ArrowError:
-      type = "Arrow C++ error";
-      break;
-    case StatusCode::UnknownError:
-      type = "Unknown error";
-      break;
-  }
-  return std::string(type);
-}
-
-std::string Status::ToString() const {
-  std::string result(CodeAsString());
-  if (state_ == NULL) {
-    return result;
-  }
-
-  result.append(": ");
-
-  uint32_t length;
-  memcpy(&length, state_, sizeof(length));
-  result.append(reinterpret_cast<const char*>(state_ + 7), length);
-  return result;
-}
-
-} // namespace pyarrow

http://git-wip-us.apache.org/repos/asf/arrow/blob/732a2059/python/src/pyarrow/status.h
----------------------------------------------------------------------
diff --git a/python/src/pyarrow/status.h b/python/src/pyarrow/status.h
deleted file mode 100644
index 67cd66c..0000000
--- a/python/src/pyarrow/status.h
+++ /dev/null
@@ -1,146 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-//
-// A Status encapsulates the result of an operation.  It may indicate success,
-// or it may indicate an error with an associated error message.
-//
-// Multiple threads can invoke const methods on a Status without
-// external synchronization, but if any of the threads may call a
-// non-const method, all threads accessing the same Status must use
-// external synchronization.
-
-#ifndef PYARROW_STATUS_H_
-#define PYARROW_STATUS_H_
-
-#include <cstdint>
-#include <cstring>
-#include <string>
-
-#include "pyarrow/visibility.h"
-
-namespace pyarrow {
-
-#define PY_RETURN_NOT_OK(s) do {                \
-    Status _s = (s);                            \
-    if (!_s.ok()) return _s;                    \
-  } while (0);
-
-enum class StatusCode: char {
-  OK = 0,
-  OutOfMemory = 1,
-  KeyError = 2,
-  TypeError = 3,
-  ValueError = 4,
-  IOError = 5,
-  NotImplemented = 6,
-
-  ArrowError = 7,
-
-  UnknownError = 10
-};
-
-class PYARROW_EXPORT Status {
- public:
-  // Create a success status.
-  Status() : state_(NULL) { }
-  ~Status() { delete[] state_; }
-
-  // Copy the specified status.
-  Status(const Status& s);
-  void operator=(const Status& s);
-
-  // Return a success status.
-  static Status OK() { return Status(); }
-
-  // Return error status of an appropriate type.
-  static Status OutOfMemory(const std::string& msg, int16_t posix_code = -1) {
-    return Status(StatusCode::OutOfMemory, msg, posix_code);
-  }
-
-  static Status KeyError(const std::string& msg) {
-    return Status(StatusCode::KeyError, msg, -1);
-  }
-
-  static Status TypeError(const std::string& msg) {
-    return Status(StatusCode::TypeError, msg, -1);
-  }
-
-  static Status IOError(const std::string& msg) {
-    return Status(StatusCode::IOError, msg, -1);
-  }
-
-  static Status ValueError(const std::string& msg) {
-    return Status(StatusCode::ValueError, msg, -1);
-  }
-
-  static Status NotImplemented(const std::string& msg) {
-    return Status(StatusCode::NotImplemented, msg, -1);
-  }
-
-  static Status UnknownError(const std::string& msg) {
-    return Status(StatusCode::UnknownError, msg, -1);
-  }
-
-  static Status ArrowError(const std::string& msg) {
-    return Status(StatusCode::ArrowError, msg, -1);
-  }
-
-  // Returns true iff the status indicates success.
-  bool ok() const { return (state_ == NULL); }
-
-  bool IsOutOfMemory() const { return code() == StatusCode::OutOfMemory; }
-  bool IsKeyError() const { return code() == StatusCode::KeyError; }
-  bool IsIOError() const { return code() == StatusCode::IOError; }
-  bool IsTypeError() const { return code() == StatusCode::TypeError; }
-  bool IsValueError() const { return code() == StatusCode::ValueError; }
-
-  bool IsUnknownError() const { return code() == StatusCode::UnknownError; }
-
-  bool IsArrowError() const { return code() == StatusCode::ArrowError; }
-
-  // Return a string representation of this status suitable for printing.
-  // Returns the string "OK" for success.
-  std::string ToString() const;
-
-  // Return a string representation of the status code, without the message
-  // text or posix code information.
-  std::string CodeAsString() const;
-
-  // Get the POSIX code associated with this Status, or -1 if there is none.
-  int16_t posix_code() const;
-
- private:
-  // OK status has a NULL state_.  Otherwise, state_ is a new[] array
-  // of the following form:
-  //    state_[0..3] == length of message
-  //    state_[4]    == code
-  //    state_[5..6] == posix_code
-  //    state_[7..]  == message
-  const char* state_;
-
-  StatusCode code() const {
-    return ((state_ == NULL) ?
-        StatusCode::OK : static_cast<StatusCode>(state_[4]));
-  }
-
-  Status(StatusCode code, const std::string& msg, int16_t posix_code);
-  static const char* CopyState(const char* s);
-};
-
-inline Status::Status(const Status& s) {
-  state_ = (s.state_ == NULL) ? NULL : CopyState(s.state_);
-}
-
-inline void Status::operator=(const Status& s) {
-  // The following condition catches both aliasing (when this == &s),
-  // and the common case where both s and *this are ok.
-  if (state_ != s.state_) {
-    delete[] state_;
-    state_ = (s.state_ == NULL) ? NULL : CopyState(s.state_);
-  }
-}
-
-}  // namespace pyarrow
-
-#endif // PYARROW_STATUS_H_


Mime
View raw message