fix linting

pcmoritz · pcmoritz · commit b1e0335a8227 · 2017-06-11T14:01:40.000-07:00
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
@@ -864,7 +864,10 @@ if (UNIX)
     IF(NOT ((item MATCHES "_generated.h") OR
             (item MATCHES "pyarrow_api.h") OR
             (item MATCHES "xxhash.h") OR
-            (item MATCHES "xxhash.cc")))
+            (item MATCHES "xxhash.cc") OR
+            (item MATCHES "config.h") OR
+            (item MATCHES "zmalloc.h") OR
+            (item MATCHES "ae.h")))
       LIST(APPEND FILTERED_LINT_FILES ${item})
     ENDIF()
   ENDFOREACH(item ${LINT_FILES})
diff --git a/cpp/src/arrow/status.h b/cpp/src/arrow/status.h
@@ -155,11 +155,17 @@ class ARROW_EXPORT Status {
   bool IsUnknownError() const { return code() == StatusCode::UnknownError; }
   bool IsNotImplemented() const { return code() == StatusCode::NotImplemented; }
   // An object with this object ID already exists in the plasma store.
-  bool IsPlasmaObjectExists() const { return code() == StatusCode::PlasmaObjectExists; }
+  bool IsPlasmaObjectExists() const {
+    return code() == StatusCode::PlasmaObjectExists;
+  }
   // An object was requested that doesn't exist in the plasma store.
-  bool IsPlasmaObjectNonexistent() const { return code() == StatusCode::PlasmaObjectNonexistent; }
+  bool IsPlasmaObjectNonexistent() const {
+    return code() == StatusCode::PlasmaObjectNonexistent;
+  }
   // An object is too large to fit into the plasma store.
-  bool IsPlasmaStoreFull() const { return code() == StatusCode::PlasmaStoreFull; }
+  bool IsPlasmaStoreFull() const {
+    return code() == StatusCode::PlasmaStoreFull;
+  }
 
   // Return a string representation of this status suitable for printing.
   // Returns the string "OK" for success.
diff --git a/cpp/src/plasma/CMakeLists.txt b/cpp/src/plasma/CMakeLists.txt
@@ -81,6 +81,7 @@ include_directories("${FLATBUFFERS_INCLUDE_DIR}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
 
 set_source_files_properties(thirdparty/dlmalloc.c PROPERTIES COMPILE_FLAGS -Wno-all)
+set_source_files_properties(extension.cc PROPERTIES COMPILE_FLAGS -Wno-strict-aliasing)
 
 add_library(plasma_lib STATIC
   client.cc
diff --git a/cpp/src/plasma/client.cc b/cpp/src/plasma/client.cc
@@ -92,7 +92,8 @@ uint8_t *lookup_or_mmap(PlasmaClient *conn,
     close(fd);
     return entry->second->pointer;
   } else {
-    uint8_t *result = reinterpret_cast<uint8_t *>(mmap(NULL, map_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
+    uint8_t *result = reinterpret_cast<uint8_t *>(
+          mmap(NULL, map_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
     if (result == MAP_FAILED) {
       ARROW_LOG(FATAL) << "mmap failed";
     }
@@ -589,10 +590,10 @@ Status PlasmaClient::Info(ObjectID object_id, int *object_status) {
   return ReadStatusReply(buffer.data(), &object_id, object_status, 1);
 }
 
-Status PlasmaClient::Wait(int num_object_requests,
+Status PlasmaClient::Wait(int64_t num_object_requests,
                           ObjectRequest object_requests[],
                           int num_ready_objects,
-                          uint64_t timeout_ms,
+                          int64_t timeout_ms,
                           int &num_objects_ready) {
   ARROW_CHECK(manager_conn >= 0);
   ARROW_CHECK(num_object_requests > 0);
diff --git a/cpp/src/plasma/client.h b/cpp/src/plasma/client.h
@@ -238,10 +238,10 @@ class PlasmaClient {
   ///        the object_requests list. If the returned number is less than
   ///        min_num_ready_objects this means that timeout expired.
   /// @return The return status.
-  Status Wait(int num_object_requests,
+  Status Wait(int64_t num_object_requests,
               ObjectRequest object_requests[],
               int num_ready_objects,
-              uint64_t timeout_ms,
+              int64_t timeout_ms,
               int &num_objects_ready);
 
   /// Transfer local object to a different plasma manager.
diff --git a/cpp/src/plasma/events.cc b/cpp/src/plasma/events.cc
@@ -28,7 +28,7 @@ void EventLoop::file_event_callback(aeEventLoop *loop,
 }
 
 int EventLoop::timer_event_callback(aeEventLoop *loop,
-                                    long long timer_id,
+                                    TimerID timer_id,
                                     void *context) {
   TimerCallback *callback = reinterpret_cast<TimerCallback *>(context);
   return (*callback)(timer_id);
diff --git a/cpp/src/plasma/events.h b/cpp/src/plasma/events.h
@@ -35,6 +35,8 @@ constexpr int kEventLoopRead = AE_READABLE;
 /// Write event on the file descriptor.
 constexpr int kEventLoopWrite = AE_WRITABLE;
 
+typedef long long TimerID; // NOLINT
+
 class EventLoop {
  public:
   // Signature of the handler that will be called when there is a new event
@@ -91,7 +93,7 @@ class EventLoop {
                                   int events);
 
   static int timer_event_callback(aeEventLoop *loop,
-                                  long long timer_id,
+                                  TimerID timer_id,
                                   void *context);
 
   aeEventLoop *loop_;
diff --git a/cpp/src/plasma/extension.cc b/cpp/src/plasma/extension.cc
@@ -19,9 +19,11 @@
 #include "plasma/common.h"
 #include "plasma/protocol.h"
 #include "plasma/client.h"
-
 #include "plasma/extension.h"
 
+#include <algorithm>
+#include <vector>
+
 PyObject *PlasmaOutOfMemoryError;
 PyObject *PlasmaObjectExistsError;
 
@@ -52,16 +54,16 @@ PyObject *PyPlasma_disconnect(PyObject *self, PyObject *args) {
    * is still active (if the context is NULL) or if it is closed (if the context
    * is (void*) 0x1). This is neccessary because the primary pointer of the
    * capsule cannot be NULL. */
-  PyCapsule_SetContext(client_capsule, (void *) 0x1);
+  PyCapsule_SetContext(client_capsule, reinterpret_cast<void *>(0x1));
   Py_RETURN_NONE;
 }
 
 PyObject *PyPlasma_create(PyObject *self, PyObject *args) {
   PlasmaClient *client;
   ObjectID object_id;
-  long long size;
+  Py_ssize_t size;
   PyObject *metadata;
-  if (!PyArg_ParseTuple(args, "O&O&LO", PyObjectToPlasmaClient, &client,
+  if (!PyArg_ParseTuple(args, "O&O&nO", PyObjectToPlasmaClient, &client,
                         PyStringToUniqueID, &object_id, &size, &metadata)) {
     return NULL;
   }
@@ -71,7 +73,7 @@ PyObject *PyPlasma_create(PyObject *self, PyObject *args) {
   }
   uint8_t *data;
   Status s = client->Create(object_id, size,
-                            (uint8_t *) PyByteArray_AsString(metadata),
+                            reinterpret_cast<uint8_t *>(PyByteArray_AsString(metadata)),
                             PyByteArray_Size(metadata), &data);
   if (s.IsPlasmaObjectExists()) {
     PyErr_SetString(PlasmaObjectExistsError,
@@ -88,9 +90,9 @@ PyObject *PyPlasma_create(PyObject *self, PyObject *args) {
   ARROW_CHECK(s.ok());
 
 #if PY_MAJOR_VERSION >= 3
-  return PyMemoryView_FromMemory((char *) data, (Py_ssize_t) size, PyBUF_WRITE);
+  return PyMemoryView_FromMemory(reinterpret_cast<char *>(data), size, PyBUF_WRITE);
 #else
-  return PyBuffer_FromReadWriteMemory((void *) data, (Py_ssize_t) size);
+  return PyBuffer_FromReadWriteMemory(reinterpret_cast<void *>(data), size);
 #endif
 }
 
@@ -105,7 +107,7 @@ PyObject *PyPlasma_hash(PyObject *self, PyObject *args) {
   bool success = plasma_compute_object_hash(client, object_id, digest);
   if (success) {
     PyObject *digest_string =
-        PyBytes_FromStringAndSize((char *) digest, kDigestSize);
+        PyBytes_FromStringAndSize(reinterpret_cast<char *>(digest), kDigestSize);
     return digest_string;
   } else {
     Py_RETURN_NONE;
@@ -137,16 +139,15 @@ PyObject *PyPlasma_release(PyObject *self, PyObject *args) {
 PyObject *PyPlasma_get(PyObject *self, PyObject *args) {
   PlasmaClient *client;
   PyObject *object_id_list;
-  long long timeout_ms;
-  if (!PyArg_ParseTuple(args, "O&OL", PyObjectToPlasmaClient, &client,
+  Py_ssize_t timeout_ms;
+  if (!PyArg_ParseTuple(args, "O&On", PyObjectToPlasmaClient, &client,
                         &object_id_list, &timeout_ms)) {
     return NULL;
   }
 
   Py_ssize_t num_object_ids = PyList_Size(object_id_list);
-  ObjectID *object_ids = (ObjectID *) malloc(sizeof(ObjectID) * num_object_ids);
-  ObjectBuffer *object_buffers =
-      (ObjectBuffer *) malloc(sizeof(ObjectBuffer) * num_object_ids);
+  ObjectID *object_ids = new ObjectID[num_object_ids];
+  ObjectBuffer *object_buffers = new ObjectBuffer[num_object_ids];
 
   for (int i = 0; i < num_object_ids; ++i) {
     PyStringToUniqueID(PyList_GetItem(object_id_list, i), &object_ids[i]);
@@ -156,39 +157,35 @@ PyObject *PyPlasma_get(PyObject *self, PyObject *args) {
   ARROW_CHECK_OK(
       client->Get(object_ids, num_object_ids, timeout_ms, object_buffers));
   Py_END_ALLOW_THREADS;
-  free(object_ids);
+  delete[] object_ids;
 
   PyObject *returns = PyList_New(num_object_ids);
   for (int i = 0; i < num_object_ids; ++i) {
     if (object_buffers[i].data_size != -1) {
       /* The object was retrieved, so return the object. */
       PyObject *t = PyTuple_New(2);
+      Py_ssize_t data_size = static_cast<Py_ssize_t>(object_buffers[i].data_size);
+      Py_ssize_t metadata_size = static_cast<Py_ssize_t>(object_buffers[i].metadata_size);
 #if PY_MAJOR_VERSION >= 3
-      PyTuple_SetItem(
-          t, 0, PyMemoryView_FromMemory(
-                    (char *) object_buffers[i].data,
-                    (Py_ssize_t) object_buffers[i].data_size, PyBUF_READ));
-      PyTuple_SetItem(
-          t, 1, PyMemoryView_FromMemory(
-                    (char *) object_buffers[i].metadata,
-                    (Py_ssize_t) object_buffers[i].metadata_size, PyBUF_READ));
+      char *data = reinterpret_cast<char *>(object_buffers[i].data);
+      char *metadata = reinterpret_cast<char *>(object_buffers[i].metadata);
+      PyTuple_SetItem(t, 0, PyMemoryView_FromMemory(data, data_size, PyBUF_READ));
+      PyTuple_SetItem(t, 1, PyMemoryView_FromMemory(metadata, metadata_size, PyBUF_READ));
 #else
-      PyTuple_SetItem(
-          t, 0, PyBuffer_FromMemory((void *) object_buffers[i].data,
-                                    (Py_ssize_t) object_buffers[i].data_size));
-      PyTuple_SetItem(t, 1, PyBuffer_FromMemory(
-                                (void *) object_buffers[i].metadata,
-                                (Py_ssize_t) object_buffers[i].metadata_size));
+      void *data = reinterpret_cast<void *>(object_buffers[i].data);
+      void *metadata = reinterpret_cast<void *>(object_buffers[i].metadata);
+      PyTuple_SetItem(t, 0, PyBuffer_FromMemory(data, data_size));
+      PyTuple_SetItem(t, 1, PyBuffer_FromMemory(metadata, metadata_size));
 #endif
       PyList_SetItem(returns, i, t);
     } else {
       /* The object was not retrieved, so just add None to the list of return
        * values. */
-      Py_XINCREF(Py_None);
+      Py_INCREF(Py_None);
       PyList_SetItem(returns, i, Py_None);
     }
   }
-  free(object_buffers);
+  delete[] object_buffers;
   return returns;
 }
 
@@ -220,21 +217,21 @@ PyObject *PyPlasma_fetch(PyObject *self, PyObject *args) {
     return NULL;
   }
   Py_ssize_t n = PyList_Size(object_id_list);
-  ObjectID *object_ids = (ObjectID *) malloc(sizeof(ObjectID) * n);
+  ObjectID *object_ids = new ObjectID[n];
   for (int i = 0; i < n; ++i) {
     PyStringToUniqueID(PyList_GetItem(object_id_list, i), &object_ids[i]);
   }
-  ARROW_CHECK_OK(client->Fetch((int) n, object_ids));
-  free(object_ids);
+  ARROW_CHECK_OK(client->Fetch(static_cast<int>(n), object_ids));
+  delete[] object_ids;
   Py_RETURN_NONE;
 }
 
 PyObject *PyPlasma_wait(PyObject *self, PyObject *args) {
   PlasmaClient *client;
   PyObject *object_id_list;
-  long long timeout;
+  Py_ssize_t timeout;
   int num_returns;
-  if (!PyArg_ParseTuple(args, "O&OLi", PyObjectToPlasmaClient, &client,
+  if (!PyArg_ParseTuple(args, "O&Oni", PyObjectToPlasmaClient, &client,
                         &object_id_list, &timeout, &num_returns)) {
     return NULL;
   }
@@ -262,8 +259,7 @@ PyObject *PyPlasma_wait(PyObject *self, PyObject *args) {
     return NULL;
   }
 
-  ObjectRequest *object_requests =
-      (ObjectRequest *) malloc(sizeof(ObjectRequest) * n);
+  std::vector<ObjectRequest> object_requests(n);
   for (int i = 0; i < n; ++i) {
     ARROW_CHECK(PyStringToUniqueID(PyList_GetItem(object_id_list, i),
                                    &object_requests[i].object_id) == 1);
@@ -273,8 +269,8 @@ PyObject *PyPlasma_wait(PyObject *self, PyObject *args) {
    * run. */
   int num_return_objects;
   Py_BEGIN_ALLOW_THREADS;
-  ARROW_CHECK_OK(client->Wait((int) n, object_requests, num_returns,
-                              (uint64_t) timeout, num_return_objects));
+  ARROW_CHECK_OK(client->Wait(n, object_requests.data(), num_returns,
+                              timeout, num_return_objects));
   Py_END_ALLOW_THREADS;
 
   int num_to_return = std::min(num_return_objects, num_returns);
@@ -287,9 +283,9 @@ PyObject *PyPlasma_wait(PyObject *self, PyObject *args) {
     }
     if (object_requests[i].status == ObjectStatus_Local ||
         object_requests[i].status == ObjectStatus_Remote) {
-      PyObject *ready =
-          PyBytes_FromStringAndSize((char *) &object_requests[i].object_id,
-                                    sizeof(object_requests[i].object_id));
+      PyObject *ready = PyBytes_FromStringAndSize(
+          reinterpret_cast<char *>(&object_requests[i].object_id),
+          sizeof(object_requests[i].object_id));
       PyList_SetItem(ready_ids, num_returned, ready);
       PySet_Discard(waiting_ids, ready);
       num_returned += 1;
@@ -307,14 +303,14 @@ PyObject *PyPlasma_wait(PyObject *self, PyObject *args) {
 
 PyObject *PyPlasma_evict(PyObject *self, PyObject *args) {
   PlasmaClient *client;
-  long long num_bytes;
-  if (!PyArg_ParseTuple(args, "O&L", PyObjectToPlasmaClient, &client,
+  Py_ssize_t num_bytes;
+  if (!PyArg_ParseTuple(args, "O&n", PyObjectToPlasmaClient, &client,
                         &num_bytes)) {
     return NULL;
   }
   int64_t evicted_bytes;
-  ARROW_CHECK_OK(client->Evict((int64_t) num_bytes, evicted_bytes));
-  return PyLong_FromLong((long) evicted_bytes);
+  ARROW_CHECK_OK(client->Evict(static_cast<int64_t>(num_bytes), evicted_bytes));
+  return PyLong_FromSsize_t(static_cast<Py_ssize_t>(evicted_bytes));
 }
 
 PyObject *PyPlasma_delete(PyObject *self, PyObject *args) {
@@ -388,7 +384,7 @@ PyObject *PyPlasma_receive_notification(PyObject *self, PyObject *args) {
     PyTuple_SetItem(t, 2, PyLong_FromLong(object_info->metadata_size()));
   }
 
-  free(notification);
+  delete[] notification;
   return t;
 }
 
diff --git a/cpp/src/plasma/extension.h b/cpp/src/plasma/extension.h
@@ -19,8 +19,9 @@
 #define PLASMA_EXTENSION_H
 
 #undef _XOPEN_SOURCE
+#undef _POSIX_C_SOURCE
 #include <Python.h>
-#include "bytesobject.h"
+#include "bytesobject.h" // NOLINT
 
 static int PyObjectToPlasmaClient(PyObject *object, PlasmaClient **client) {
   if (PyCapsule_IsValid(object, "plasma")) {
diff --git a/cpp/src/plasma/malloc.cc b/cpp/src/plasma/malloc.cc
@@ -26,6 +26,7 @@
 #include <unordered_map>
 
 #include "plasma/common.h"
+#include "plasma/malloc.h"
 
 extern "C" {
 void *fake_mmap(size_t);
diff --git a/cpp/src/plasma/plasma.cc b/cpp/src/plasma/plasma.cc
@@ -47,13 +47,13 @@ int warn_if_sigpipe(int status, int client_sock) {
  *
  * @param object_info The object info to be serialized
  * @return The object info buffer. It is the caller's responsibility to free
- *         this buffer with "free" after it has been used.
+ *         this buffer with "delete" after it has been used.
  */
 uint8_t *create_object_info_buffer(ObjectInfoT *object_info) {
   flatbuffers::FlatBufferBuilder fbb;
   auto message = CreateObjectInfo(fbb, object_info);
   fbb.Finish(message);
-  uint8_t *notification = reinterpret_cast<uint8_t *>(malloc(sizeof(int64_t) + fbb.GetSize()));
+  uint8_t *notification = new uint8_t[sizeof(int64_t) + fbb.GetSize()];
   *(reinterpret_cast<int64_t *>(notification)) = fbb.GetSize();
   memcpy(notification + sizeof(int64_t), fbb.GetBufferPointer(), fbb.GetSize());
   return notification;
diff --git a/cpp/src/plasma/protocol.cc b/cpp/src/plasma/protocol.cc
@@ -457,7 +457,7 @@ Status ReadFetchRequest(uint8_t *data, std::vector<ObjectID> &object_ids) {
 
 Status SendWaitRequest(int sock,
                        ObjectRequest object_requests[],
-                       int num_requests,
+                       int64_t num_requests,
                        int num_ready_objects,
                        int64_t timeout_ms) {
   flatbuffers::FlatBufferBuilder fbb;
diff --git a/cpp/src/plasma/protocol.h b/cpp/src/plasma/protocol.h
@@ -167,7 +167,7 @@ Status ReadFetchRequest(uint8_t *data, std::vector<ObjectID> &object_ids);
 
 Status SendWaitRequest(int sock,
                        ObjectRequest object_requests[],
-                       int num_requests,
+                       int64_t num_requests,
                        int num_ready_objects,
                        int64_t timeout_ms);
 
diff --git a/cpp/src/plasma/store.cc b/cpp/src/plasma/store.cc
diff --git a/cpp/src/plasma/test/client_tests.cc b/cpp/src/plasma/test/client_tests.cc
diff --git a/cpp/src/plasma/test/serialization_tests.cc b/cpp/src/plasma/test/serialization_tests.cc

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ void EventLoop::file_event_callback(aeEventLoop *loop,`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`int EventLoop::timer_event_callback(aeEventLoop *loop,`
`31`		`- long long timer_id,`
	`31`	`+ TimerID timer_id,`
`32`	`32`	`void *context) {`
`33`	`33`	`TimerCallback callback = reinterpret_cast<TimerCallback >(context);`
`34`	`34`	`return (*callback)(timer_id);`