More interface updates.

libgearman/connection.cc

@@ -335,7 +335,7 @@ gearman_return_t gearman_connection_send(gearman_connection_st *connection,
     while (1)
     {
       gearman_return_t rc;
-      send_size= gearman_packet_pack(packet,
+      send_size= gearman_packet_pack(*packet,
                                      connection->send_buffer + connection->send_buffer_size,
                                      GEARMAN_SEND_BUFFER_SIZE -
                                      connection->send_buffer_size, rc);
@@ -770,7 +770,7 @@ gearman_packet_st *gearman_connection_recv(gearman_connection_st *connection,
     {
       if (connection->recv_buffer_size > 0)
       {
-        size_t recv_size= gearman_packet_unpack(connection->recv_packet,
+        size_t recv_size= gearman_packet_unpack(*connection->recv_packet,
                                                 connection->recv_buffer_ptr,
                                                 connection->recv_buffer_size, *ret_ptr);
         connection->recv_buffer_ptr+= recv_size;

libgearman/job.cc

@@ -485,7 +485,7 @@ size_t gearman_job_workload_size(const gearman_job_st *job)
 
 void *gearman_job_take_workload(gearman_job_st *job, size_t *data_size)
 {
-  return gearman_packet_take_data(&(job->assigned), data_size);
+  return gearman_packet_take_data(job->assigned, data_size);
 }
 
 void gearman_job_free(gearman_job_st *job)

libgearman/packet.cc

@@ -186,10 +186,10 @@ gearman_packet_st *gearman_packet_create(gearman_universal_st &universal,
   return packet;
 }
 
-gearman_return_t gearman_packet_create_arg(gearman_packet_st *packet,
+gearman_return_t gearman_packet_create_arg(gearman_packet_st& self,
                                            const void *arg, size_t arg_size)
 {
-  return packet_create_arg(packet, arg, arg_size);
+  return packet_create_arg(&self, arg, arg_size);
 }
 
 gearman_return_t gearman_packet_create_args(gearman_universal_st& universal,
@@ -247,7 +247,7 @@ void gearman_packet_free(gearman_packet_st *packet)
     packet->args= NULL;
   }
 
-  if (packet->options.free_data && packet->data != NULL)
+  if (packet->options.free_data && packet->data)
   {
     if (packet->universal->workload_free_fn)
     {
@@ -266,9 +266,11 @@ void gearman_packet_free(gearman_packet_st *packet)
   {
     if (packet->universal->packet_list == packet)
       packet->universal->packet_list= packet->next;
-    if (packet->prev != NULL)
+
+    if (packet->prev)
       packet->prev->next= packet->next;
-    if (packet->next != NULL)
+
+    if (packet->next)
       packet->next->prev= packet->prev;
     packet->universal->packet_count--;
   }
@@ -285,8 +287,6 @@ void gearman_packet_free(gearman_packet_st *packet)
 
 gearman_return_t gearman_packet_pack_header(gearman_packet_st *packet)
 {
-  uint64_t length_64;
-
   if (packet->magic == GEARMAN_MAGIC_TEXT)
   {
     packet->options.complete= true;
@@ -329,7 +329,7 @@ gearman_return_t gearman_packet_pack_header(gearman_packet_st *packet)
   // Record the command
   memcpy(packet->args + 4, &tmp, 4);
 
-  length_64= packet->args_size + packet->data_size - GEARMAN_PACKET_HEADER_SIZE;
+  uint64_t length_64= packet->args_size + packet->data_size - GEARMAN_PACKET_HEADER_SIZE;
 
   // Check for overflow on 32bit(portable?).
   if (length_64 >= UINT32_MAX || length_64 < packet->data_size)
@@ -382,36 +382,35 @@ gearman_return_t gearman_packet_unpack_header(gearman_packet_st *packet)
   return GEARMAN_SUCCESS;
 }
 
-size_t gearman_packet_pack(const gearman_packet_st *packet,
+size_t gearman_packet_pack(const gearman_packet_st &self,
                            void *data, size_t data_size,
                            gearman_return_t &ret)
 {
-  if (not packet->args_size)
+  if (not self.args_size)
   {
     ret= GEARMAN_SUCCESS;
     return 0;
   }
 
-  if (packet->args_size > data_size)
+  if (self.args_size > data_size)
   {
     ret= GEARMAN_FLUSH_DATA;
     return 0;
   }
 
-  memcpy(data, packet->args, packet->args_size);
+  memcpy(data, self.args, self.args_size);
   ret= GEARMAN_SUCCESS;
-  return packet->args_size;
+  return self.args_size;
 }
 
-size_t gearman_packet_unpack(gearman_packet_st *packet,
+size_t gearman_packet_unpack(gearman_packet_st& self,
                              const void *data, size_t data_size,
                              gearman_return_t &ret)
 {
   size_t used_size;
   size_t arg_size;
 
-  assert(packet);
-  if (packet->args_size == 0)
+  if (self.args_size == 0)
   {
     if (data_size > 0 && ((uint8_t *)data)[0] != 0)
     {
@@ -419,13 +418,13 @@ size_t gearman_packet_unpack(gearman_packet_st *packet,
       uint8_t *ptr= (uint8_t *)memchr(data, '\n', data_size);
       if (not ptr)
       {
-        gearman_gerror(packet->universal, GEARMAN_IO_WAIT);
+        gearman_gerror(self.universal, GEARMAN_IO_WAIT);
         ret= GEARMAN_IO_WAIT;
         return 0;
       }
 
-      packet->magic= GEARMAN_MAGIC_TEXT;
-      packet->command= GEARMAN_COMMAND_TEXT;
+      self.magic= GEARMAN_MAGIC_TEXT;
+      self.command= GEARMAN_COMMAND_TEXT;
 
       used_size= (size_t)(ptr - ((uint8_t *)data)) + 1;
       *ptr= 0;
@@ -445,8 +444,8 @@ size_t gearman_packet_unpack(gearman_packet_st *packet,
           arg_size-= (size_t)(ptr - ((uint8_t *)data));
         }
 
-        ret= packet_create_arg(packet, data, ptr == NULL ? arg_size :
-                               (size_t)(ptr - ((uint8_t *)data)));
+        ret= packet_create_arg(&self, data, 
+                               ptr == NULL ? arg_size : size_t(ptr - ((uint8_t *)data)));
         if (gearman_failed(ret))
         {
           return used_size;
@@ -457,16 +456,16 @@ size_t gearman_packet_unpack(gearman_packet_st *packet,
     }
     else if (data_size < GEARMAN_PACKET_HEADER_SIZE)
     {
-      gearman_gerror(packet->universal, GEARMAN_IO_WAIT);
+      gearman_gerror(self.universal, GEARMAN_IO_WAIT);
       ret= GEARMAN_IO_WAIT;
       return 0;
     }
 
-    packet->args= packet->args_buffer;
-    packet->args_size= GEARMAN_PACKET_HEADER_SIZE;
-    memcpy(packet->args, data, GEARMAN_PACKET_HEADER_SIZE);
+    self.args= self.args_buffer;
+    self.args_size= GEARMAN_PACKET_HEADER_SIZE;
+    memcpy(self.args, data, GEARMAN_PACKET_HEADER_SIZE);
 
-    ret= gearman_packet_unpack_header(packet);
+    ret= gearman_packet_unpack_header(&self);
     if (gearman_failed(ret))
     {
       return 0;
@@ -479,47 +478,47 @@ size_t gearman_packet_unpack(gearman_packet_st *packet,
     used_size= 0;
   }
 
-  while (packet->argc != gearman_command_info(packet->command)->argc)
+  while (self.argc != gearman_command_info(self.command)->argc)
   {
-    if (packet->argc != (gearman_command_info(packet->command)->argc - 1) ||
-        gearman_command_info(packet->command)->data)
+    if (self.argc != (gearman_command_info(self.command)->argc - 1) ||
+        gearman_command_info(self.command)->data)
     {
 
       uint8_t *ptr= (uint8_t *)memchr((char *)data + used_size, 0, data_size - used_size);
       if (not ptr)
       {
-        gearman_gerror(packet->universal, GEARMAN_IO_WAIT);
+        gearman_gerror(self.universal, GEARMAN_IO_WAIT);
         ret= GEARMAN_IO_WAIT;
         return used_size;
       }
 
       arg_size= (size_t)(ptr - ((uint8_t *)data + used_size)) + 1;
-      ret= packet_create_arg(packet, (uint8_t *)data + used_size, arg_size);
+      ret= packet_create_arg(&self, (uint8_t *)data + used_size, arg_size);
       if (gearman_failed(ret))
       {
         return used_size;
       }
 
-      packet->data_size-= arg_size;
+      self.data_size-= arg_size;
       used_size+= arg_size;
     }
     else
     {
-      if ((data_size - used_size) < packet->data_size)
+      if ((data_size - used_size) < self.data_size)
       {
-        gearman_gerror(packet->universal, GEARMAN_IO_WAIT);
+        gearman_gerror(self.universal, GEARMAN_IO_WAIT);
         ret= GEARMAN_IO_WAIT;
         return used_size;
       }
 
-      ret= packet_create_arg(packet, ((uint8_t *)data) + used_size, packet->data_size);
+      ret= packet_create_arg(&self, ((uint8_t *)data) + used_size, self.data_size);
       if (gearman_failed(ret))
       {
         return used_size;
       }
 
-      used_size+= packet->data_size;
-      packet->data_size= 0;
+      used_size+= self.data_size;
+      self.data_size= 0;
     }
   }
 
@@ -527,23 +526,23 @@ size_t gearman_packet_unpack(gearman_packet_st *packet,
   return used_size;
 }
 
-void gearman_packet_give_data(gearman_packet_st *packet, const void *data,
-                              size_t data_size)
+void gearman_packet_give_data(gearman_packet_st& self,
+                              const void *data, size_t data_size)
 {
-  packet->data= data;
-  packet->data_size= data_size;
-  packet->options.free_data= true;
+  self.data= data;
+  self.data_size= data_size;
+  self.options.free_data= true;
 }
 
-void *gearman_packet_take_data(gearman_packet_st *packet, size_t *data_size)
+void *gearman_packet_take_data(gearman_packet_st& self, size_t *data_size)
 {
-  void *data= const_cast<void *>(packet->data);
+  void *data= const_cast<void *>(self.data);
 
-  *data_size= packet->data_size;
+  *data_size= self.data_size;
 
-  packet->data= NULL;
-  packet->data_size= 0;
-  packet->options.free_data= false;
+  self.data= NULL;
+  self.data_size= 0;
+  self.options.free_data= false;
 
   return data;
 }

libgearman/packet.h

@@ -100,19 +100,6 @@ typedef size_t (gearman_packet_pack_fn)(const gearman_packet_st *packet,
 typedef size_t (gearman_packet_unpack_fn)(gearman_packet_st *packet,
                                           const void *data, size_t data_size,
                                           gearman_return_t *ret_ptr);
-/**
- * Command information array.
- * @ingroup gearman_constants
- */
-extern GEARMAN_INTERNAL_API
-gearman_command_info_st gearman_command_info_list[GEARMAN_COMMAND_MAX];
-
-/**
- * Add an argument to a packet.
- */
-GEARMAN_INTERNAL_API
-gearman_return_t gearman_packet_create_arg(gearman_packet_st *packet,
-                                           const void *arg, size_t arg_size);
 
 /**
  * Pack header.
@@ -126,40 +113,9 @@ gearman_return_t gearman_packet_pack_header(gearman_packet_st *packet);
 GEARMAN_INTERNAL_API
 gearman_return_t gearman_packet_unpack_header(gearman_packet_st *packet);
 
-/**
- * Give allocated memory to packet. After this, the library will be responsible
- * for freeing the workload memory when the packet is destroyed.
- */
-GEARMAN_INTERNAL_API
-void gearman_packet_give_data(gearman_packet_st *packet, const void *data,
-                              size_t data_size);
-
-/**
- * Take allocated data from packet. After this, the caller is responsible for
- * free()ing the memory.
- */
-GEARMAN_INTERNAL_API
-void *gearman_packet_take_data(gearman_packet_st *packet, size_t *data_size);
-
 
 #ifdef __cplusplus
 }
-
-/**
- * Pack packet into output buffer.
- */
-GEARMAN_INTERNAL_API
-size_t gearman_packet_pack(const gearman_packet_st *packet,
-                           void *data, size_t data_size,
-                           gearman_return_t &ret);
-
-/**
- * Unpack packet from input data.
- */
-GEARMAN_INTERNAL_API
-size_t gearman_packet_unpack(gearman_packet_st *packet,
-                             const void *data, size_t data_size,
-                             gearman_return_t &ret);
 #endif
 
 #endif /* GEARMAN_CORE */

libgearman/packet.hpp

@@ -73,3 +73,42 @@ gearman_return_t gearman_packet_create_args(gearman_universal_st&,
                                             const void *args[],
                                             const size_t args_size[],
                                             size_t args_count);
+
+/**
+ * Give allocated memory to packet. After this, the library will be responsible
+ * for freeing the workload memory when the packet is destroyed.
+ */
+GEARMAN_LOCAL
+void gearman_packet_give_data(gearman_packet_st& packet, 
+                              const void *data, size_t data_size);
+
+/**
+ * Take allocated data from packet. After this, the caller is responsible for
+ * free()ing the memory.
+ */
+GEARMAN_LOCAL
+void *gearman_packet_take_data(gearman_packet_st& packet, size_t *data_size);
+
+/**
+ * Pack packet into output buffer.
+ */
+GEARMAN_LOCAL
+size_t gearman_packet_pack(const gearman_packet_st& packet,
+                           void *data, size_t data_size,
+                           gearman_return_t &ret);
+
+/**
+ * Unpack packet from input data.
+ */
+GEARMAN_LOCAL
+size_t gearman_packet_unpack(gearman_packet_st& packet,
+                             const void *data, size_t data_size,
+                             gearman_return_t &ret);
+
+/**
+ * Add an argument to a packet.
+ */
+GEARMAN_LOCAL
+gearman_return_t gearman_packet_create_arg(gearman_packet_st& packet,
+                                           const void *arg, size_t arg_size);
+

libgearman/task.cc

@@ -275,7 +275,7 @@ void gearman_task_give_workload(gearman_task_st *task, const void *workload,
   if (not task)
     return;
 
-  gearman_packet_give_data(&(task->send), workload, workload_size);
+  gearman_packet_give_data(task->send, workload, workload_size);
 }
 
 size_t gearman_task_send_workload(gearman_task_st *task, const void *workload,
@@ -332,7 +332,7 @@ void *gearman_task_take_data(gearman_task_st *task, size_t *data_size)
   if (not task)
     return 0;
 
-  return gearman_packet_take_data(task->recv, data_size);
+  return gearman_packet_take_data(*task->recv, data_size);
 }
 
 size_t gearman_task_recv_data(gearman_task_st *task, void *data,

tests/internals.cc

@@ -329,20 +329,18 @@ static test_return_t gearman_packet_give_data_test(void *)
   gearman_universal_st universal;
 
   gearman_packet_st packet;
-  gearman_packet_st *packet_ptr;
 
   gearman_universal_initialize(universal);
 
-  packet_ptr= gearman_packet_create(universal, &packet);
-  test_truth(packet_ptr);
+  test_truth(gearman_packet_create(universal, &packet));
 
-  gearman_packet_give_data(packet_ptr, data, data_size);
+  gearman_packet_give_data(packet, data, data_size);
 
-  test_truth(packet_ptr->data == data);
-  test_truth(packet_ptr->data_size == data_size);
-  test_truth(packet_ptr->options.free_data);
+  test_truth(packet.data == data);
+  test_truth(packet.data_size == data_size);
+  test_truth(packet.options.free_data);
 
-  gearman_packet_free(packet_ptr);
+  gearman_packet_free(&packet);
   gearman_universal_free(universal);
 
   return TEST_SUCCESS;
@@ -361,14 +359,14 @@ static test_return_t gearman_packet_take_data_test(void *)
   gearman_packet_st *packet_ptr= gearman_packet_create(universal, &packet);
   test_truth(packet_ptr);
 
-  gearman_packet_give_data(packet_ptr, data, data_size);
+  gearman_packet_give_data(packet, data, data_size);
 
   test_truth(packet_ptr->data == data);
   test_compare(data_size, packet_ptr->data_size);
   test_truth(packet_ptr->options.free_data);
 
   size_t mine_size;
-  char *mine= (char *)gearman_packet_take_data(packet_ptr, &mine_size);
+  char *mine= (char *)gearman_packet_take_data(packet, &mine_size);
 
   test_false(packet_ptr->data);
   test_compare(0, packet_ptr->data_size);