Merge lp:~brianaker/gearmand/client_impl_cleanup into lp:gearmand

[Brian Aker]

=== modified file 'libgearman/add.cc'
--- libgearman/add.cc	2013-07-06 17:53:34 +0000
+++ libgearman/add.cc	2013-07-07 00:33:27 +0000
@@ -119,7 +119,7 @@
 
 } // namespace
 
-gearman_task_st *add_task(gearman_client_st& client,
+gearman_task_st *add_task(Client& client,
                           void *context,
                           gearman_command_t command,
                           const gearman_string_t &function,
@@ -131,7 +131,7 @@
   return add_task(client, NULL, context, command, function, unique, workload, when, actions);
 }
 
-gearman_task_st *add_task_ptr(gearman_client_st& client,
+gearman_task_st *add_task_ptr(Client& client,
                               gearman_task_st *task,
                               void *context,
                               gearman_command_t command,
@@ -149,7 +149,7 @@
   task= add_task(client, task, context, command, function, local_unique, workload, when, actions);
   if (task == NULL)
   {
-    ret_ptr= client.impl()->universal.error_code();
+    ret_ptr= client.universal.error_code();
     return NULL;
   }
 
@@ -158,7 +158,7 @@
   return task;
 }
 
-gearman_task_st *add_task(gearman_client_st& client,
+gearman_task_st *add_task(Client& client,
                           gearman_task_st *task_shell,
                           void *context,
                           gearman_command_t command,
@@ -172,11 +172,11 @@
   {
     if (gearman_size(function) > GEARMAN_FUNCTION_MAX_SIZE)
     {
-      gearman_error(client.impl()->universal, GEARMAN_INVALID_ARGUMENT, "function name longer then GEARMAN_MAX_FUNCTION_SIZE");
+      gearman_error(client.universal, GEARMAN_INVALID_ARGUMENT, "function name longer then GEARMAN_MAX_FUNCTION_SIZE");
     } 
     else
     {
-      gearman_error(client.impl()->universal, GEARMAN_INVALID_ARGUMENT, "invalid function");
+      gearman_error(client.universal, GEARMAN_INVALID_ARGUMENT, "invalid function");
     }
 
     return NULL;
@@ -184,21 +184,21 @@
 
   if (gearman_size(unique) > GEARMAN_MAX_UNIQUE_SIZE)
   {
-    gearman_error(client.impl()->universal, GEARMAN_INVALID_ARGUMENT, "unique name longer then GEARMAN_MAX_UNIQUE_SIZE");
+    gearman_error(client.universal, GEARMAN_INVALID_ARGUMENT, "unique name longer then GEARMAN_MAX_UNIQUE_SIZE");
 
     return NULL;
   }
 
   if ((gearman_size(workload) && gearman_c_str(workload) == NULL) or (gearman_size(workload) == 0 && gearman_c_str(workload)))
   {
-    gearman_error(client.impl()->universal, GEARMAN_INVALID_ARGUMENT, "invalid workload");
+    gearman_error(client.universal, GEARMAN_INVALID_ARGUMENT, "invalid workload");
     return NULL;
   }
 
-  task_shell= gearman_task_internal_create(client, task_shell);
+  task_shell= gearman_task_internal_create(&client, task_shell);
   if (task_shell == NULL or task_shell->impl() == NULL)
   {
-    assert(client.impl()->universal.error());
+    assert(client.universal.error());
     return NULL;
   }
   assert(task_shell->impl()->client);
@@ -224,7 +224,7 @@
   }
   else
   {
-    if (client.impl()->options.generate_unique or is_background(command))
+    if (client.options.generate_unique or is_background(command))
     {
       if (safe_uuid_generate(task->unique, task->unique_length) == -1)
       {
@@ -324,8 +324,8 @@
 
   if (gearman_success(rc))
   {
-    client.impl()->new_tasks++;
-    client.impl()->running_tasks++;
+    client.new_tasks++;
+    client.running_tasks++;
     task->options.send_in_use= true;
 
     return task->shell();
@@ -336,7 +336,7 @@
   return NULL;
 }
 
-gearman_task_st *add_reducer_task(gearman_client_st *client,
+gearman_task_st *add_reducer_task(Client* client,
                                   gearman_command_t command,
                                   const gearman_job_priority_t,
                                   const gearman_string_t &function,
@@ -354,11 +354,11 @@
   {
     if (gearman_size(function) > GEARMAN_FUNCTION_MAX_SIZE)
     {
-      gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "function name longer then GEARMAN_MAX_FUNCTION_SIZE");
+      gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "function name longer then GEARMAN_MAX_FUNCTION_SIZE");
     } 
     else
     {
-      gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "invalid function");
+      gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "invalid function");
     }
 
     return NULL;
@@ -366,21 +366,21 @@
 
   if (gearman_size(unique) > GEARMAN_MAX_UNIQUE_SIZE)
   {
-    gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "unique name longer then GEARMAN_MAX_UNIQUE_SIZE");
+    gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "unique name longer then GEARMAN_MAX_UNIQUE_SIZE");
 
     return NULL;
   }
 
   if ((gearman_size(workload) and not gearman_c_str(workload)) or (gearman_size(workload) == 0 && gearman_c_str(workload)))
   {
-    gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "invalid workload");
+    gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "invalid workload");
     return NULL;
   }
 
-  gearman_task_st *task_shell= gearman_task_internal_create(*client, NULL);
+  gearman_task_st *task_shell= gearman_task_internal_create(client, NULL);
   if (task_shell == NULL)
   {
-    assert(client->impl()->universal.error_code());
+    assert(client->universal.error_code());
     return NULL;
   }
 
@@ -392,11 +392,11 @@
     @todo fix it so that NULL is done by default by the API not by happenstance.
   */
   char function_buffer[1024];
-  if (client->impl()->universal._namespace)
+  if (client->universal._namespace)
   {
     char *ptr= function_buffer;
-    memcpy(ptr, gearman_string_value(client->impl()->universal._namespace), gearman_string_length(client->impl()->universal._namespace)); 
-    ptr+= gearman_string_length(client->impl()->universal._namespace);
+    memcpy(ptr, gearman_string_value(client->universal._namespace), gearman_string_length(client->universal._namespace)); 
+    ptr+= gearman_string_length(client->universal._namespace);
 
     memcpy(ptr, gearman_c_str(function), gearman_size(function) +1);
     ptr+= gearman_size(function);
@@ -426,7 +426,7 @@
   }
   else
   {
-    if (client->impl()->options.generate_unique or is_background(command))
+    if (client->options.generate_unique or is_background(command))
     {
       safe_uuid_generate(task->unique, task->unique_length);
     }
@@ -444,11 +444,11 @@
              "Command was not appropriate for request");
 
   char reducer_buffer[1024];
-  if (client->impl()->universal._namespace)
+  if (client->universal._namespace)
   {
     char *ptr= reducer_buffer;
-    memcpy(ptr, gearman_string_value(client->impl()->universal._namespace), gearman_string_length(client->impl()->universal._namespace)); 
-    ptr+= gearman_string_length(client->impl()->universal._namespace);
+    memcpy(ptr, gearman_string_value(client->universal._namespace), gearman_string_length(client->universal._namespace)); 
+    ptr+= gearman_string_length(client->universal._namespace);
 
     memcpy(ptr, gearman_c_str(reducer), gearman_size(reducer) +1);
     ptr+= gearman_size(reducer);
@@ -473,18 +473,18 @@
   args_size[4]= gearman_size(workload);
 
   gearman_return_t rc;
-  if (gearman_success(rc= gearman_packet_create_args(client->impl()->universal, task->send,
+  if (gearman_success(rc= gearman_packet_create_args(client->universal, task->send,
                                                      GEARMAN_MAGIC_REQUEST, command,
                                                      args, args_size,
                                                      5)))
   {
-    client->impl()->new_tasks++;
-    client->impl()->running_tasks++;
+    client->new_tasks++;
+    client->running_tasks++;
     task->options.send_in_use= true;
   }
   else
   {
-    gearman_gerror(client->impl()->universal, rc);
+    gearman_gerror(client->universal, rc);
     gearman_task_free(task);
     task= NULL;
   }
 
=== modified file 'libgearman/add.hpp'
--- libgearman/add.hpp	2013-07-03 09:00:14 +0000
+++ libgearman/add.hpp	2013-07-07 00:33:27 +0000
@@ -42,7 +42,7 @@
 
 #pragma once
 
-gearman_task_st *add_task(gearman_client_st& client,
+gearman_task_st *add_task(Client& client,
                           void *context,
                           gearman_command_t command,
                           const gearman_string_t &function,
@@ -51,7 +51,7 @@
                           time_t when,
                           const gearman_actions_t &actions);
 
-gearman_task_st *add_task_ptr(gearman_client_st& client,
+gearman_task_st *add_task_ptr(Client& client,
                               gearman_task_st *task,
                               void *context,
                               gearman_command_t command,
@@ -62,7 +62,7 @@
                               gearman_return_t& ret_ptr,
                               const gearman_actions_t &actions);
 
-gearman_task_st *add_task(gearman_client_st& client,
+gearman_task_st *add_task(Client& client,
                           gearman_task_st *task,
                           void *context,
                           gearman_command_t command,
@@ -72,7 +72,7 @@
                           time_t when,
                           const gearman_actions_t &actions);
 
-gearman_task_st *add_reducer_task(gearman_client_st *client,
+gearman_task_st *add_reducer_task(Client *client,
                                   gearman_command_t command,
                                   const gearman_job_priority_t priority,
                                   const gearman_string_t &function,
 
=== modified file 'libgearman/client.cc'
--- libgearman/client.cc	2013-07-06 19:11:08 +0000
+++ libgearman/client.cc	2013-07-07 00:33:27 +0000
@@ -125,7 +125,7 @@
   gearman_task_st do_task;
   {
     client->universal.options.no_new_data= true;
-    gearman_task_st *do_task_ptr= add_task(*(client->shell()), &do_task, NULL, command,
+    gearman_task_st *do_task_ptr= add_task(*client, &do_task, NULL, command,
                                            function,
                                            local_unique,
                                            workload,
@@ -237,7 +237,7 @@
   gearman_task_st do_task;
   {
     client->universal.options.no_new_data= true;
-    gearman_task_st* do_task_ptr= add_task(*client_shell, &do_task, 
+    gearman_task_st* do_task_ptr= add_task(*client, &do_task, 
                                            client, 
                                            command,
                                            function,
@@ -826,7 +826,7 @@
   gearman_status_t status;
   gearman_init(status);
 
-  if (client == NULL)
+  if (client == NULL or client->impl() == NULL)
   {
     gearman_status_set_return(status, GEARMAN_INVALID_ARGUMENT);
     return status;
@@ -889,7 +889,7 @@
   return status;
 }
 
-gearman_return_t gearman_client_job_status(gearman_client_st *client,
+gearman_return_t gearman_client_job_status(gearman_client_st *client_shell,
                                            const gearman_job_handle_t job_handle,
                                            bool *is_known, bool *is_running,
                                            uint32_t *numerator,
@@ -897,16 +897,18 @@
 {
   gearman_return_t ret;
 
-  if (client == NULL)
+  if (client_shell == NULL or client_shell->impl() == NULL)
   {
     return GEARMAN_INVALID_ARGUMENT;
   }
 
-  client->impl()->universal.reset_error();
+  Client* client= client_shell->impl();
+
+  client->universal.reset_error();
 
   gearman_task_st do_task;
   {
-    gearman_task_st *do_task_ptr= gearman_client_add_task_status(client, &do_task, client,
+    gearman_task_st *do_task_ptr= gearman_client_add_task_status(client_shell, &do_task, client,
                                                                  job_handle, &ret);
     if (gearman_failed(ret))
     {
@@ -918,7 +920,7 @@
 
   gearman_task_clear_fn(&do_task);
 
-  ret= gearman_client_run_block_tasks(client, &do_task);
+  ret= gearman_client_run_block_tasks(client_shell, &do_task);
 
   // @note we don't know if our task was run or not, we just know something
   // happened.
@@ -1049,13 +1051,13 @@
     ret_ptr= &unused;
   }
 
-  if (client == NULL)
+  if (client == NULL or client->impl() == NULL)
   {
     *ret_ptr= GEARMAN_INVALID_ARGUMENT;
     return NULL;
   }
 
-  return add_task_ptr(*client, task,
+  return add_task_ptr(*(client->impl()), task,
                       context, GEARMAN_COMMAND_SUBMIT_JOB,
                       function,
                       unique,
@@ -1079,13 +1081,13 @@
     ret_ptr= &unused;
   }
 
-  if (client == NULL)
+  if (client == NULL or client->impl() == NULL)
   {
     *ret_ptr= GEARMAN_INVALID_ARGUMENT;
     return NULL;
   }
 
-  return add_task_ptr(*client, task, context,
+  return add_task_ptr(*(client->impl()), task, context,
                       GEARMAN_COMMAND_SUBMIT_JOB_HIGH,
                       function,
                       unique,
@@ -1109,13 +1111,13 @@
     ret_ptr= &unused;
   }
 
-  if (client == NULL)
+  if (client == NULL or client->impl() == NULL)
   {
     *ret_ptr= GEARMAN_INVALID_ARGUMENT;
     return NULL;
   }
 
-  return add_task_ptr(*client, task, context, GEARMAN_COMMAND_SUBMIT_JOB_LOW,
+  return add_task_ptr(*(client->impl()), task, context, GEARMAN_COMMAND_SUBMIT_JOB_LOW,
                       function,
                       unique,
                       workload, workload_size,
@@ -1138,13 +1140,13 @@
     ret_ptr= &unused;
   }
 
-  if (client == NULL)
+  if (client == NULL or client->impl() == NULL)
   {
     *ret_ptr= GEARMAN_INVALID_ARGUMENT;
     return NULL;
   }
 
-  return add_task_ptr(*client, task, context, GEARMAN_COMMAND_SUBMIT_JOB_BG,
+  return add_task_ptr(*(client->impl()), task, context, GEARMAN_COMMAND_SUBMIT_JOB_BG,
                       function,
                       unique,
                       workload, workload_size,
@@ -1168,13 +1170,13 @@
     ret_ptr= &unused;
   }
 
-  if (client == NULL)
+  if (client == NULL or client->impl() == NULL)
   {
     *ret_ptr= GEARMAN_INVALID_ARGUMENT;
     return NULL;
   }
 
-  return add_task_ptr(*client, task, context,
+  return add_task_ptr(*(client->impl()), task, context,
                       GEARMAN_COMMAND_SUBMIT_JOB_HIGH_BG,
                       function,
                       unique,
@@ -1198,13 +1200,13 @@
     ret_ptr= &unused;
   }
 
-  if (client == NULL)
+  if (client == NULL or client->impl() == NULL)
   {
     *ret_ptr= GEARMAN_INVALID_ARGUMENT;
     return NULL;
   }
 
-  return add_task_ptr(*client, task, context,
+  return add_task_ptr(*(client->impl()), task, context,
                       GEARMAN_COMMAND_SUBMIT_JOB_LOW_BG,
                       function,
                       unique,
@@ -1215,7 +1217,7 @@
 
 }
 
-gearman_task_st *gearman_client_add_task_status(gearman_client_st *client,
+gearman_task_st *gearman_client_add_task_status(gearman_client_st *client_shell,
                                                 gearman_task_st *task_shell,
                                                 void *context,
                                                 const gearman_job_handle_t job_handle,
@@ -1230,15 +1232,16 @@
     ret_ptr= &unused;
   }
 
-  if (client == NULL)
+  if (client_shell == NULL or client_shell->impl() == NULL)
   {
     *ret_ptr= GEARMAN_INVALID_ARGUMENT;
     return NULL;
   }
+  Client* client= client_shell->impl();
 
-  if ((task_shell= gearman_task_internal_create(*client, task_shell)) == NULL)
+  if ((task_shell= gearman_task_internal_create(client, task_shell)) == NULL)
   {
-    *ret_ptr= gearman_client_error_code(client);
+    *ret_ptr= gearman_client_error_code(client_shell);
     return NULL;
   }
 
@@ -1249,14 +1252,14 @@
 
   args[0]= job_handle;
   args_size[0]= strlen(job_handle);
-  gearman_return_t rc= gearman_packet_create_args(client->impl()->universal, task->send,
+  gearman_return_t rc= gearman_packet_create_args(client->universal, task->send,
                                                   GEARMAN_MAGIC_REQUEST,
                                                   GEARMAN_COMMAND_GET_STATUS,
                                                   args, args_size, 1);
   if (gearman_success(rc))
   {
-    client->impl()->new_tasks++;
-    client->impl()->running_tasks++;
+    client->new_tasks++;
+    client->running_tasks++;
     task->options.send_in_use= true;
   }
   *ret_ptr= rc;
@@ -1264,7 +1267,7 @@
   return task_shell;
 }
 
-gearman_task_st *gearman_client_add_task_status_by_unique(gearman_client_st *client,
+gearman_task_st *gearman_client_add_task_status_by_unique(gearman_client_st *client_shell,
                                                           gearman_task_st *task_shell,
                                                           const char *unique_handle,
                                                           gearman_return_t *ret_ptr)
@@ -1278,11 +1281,12 @@
     ret_ptr= &unused;
   }
 
-  if (client == NULL)
+  if (client_shell == NULL or client_shell->impl() == NULL)
   {
     *ret_ptr= GEARMAN_INVALID_ARGUMENT;
     return NULL;
   }
+  Client* client= client_shell->impl();
 
   if (unique_handle == NULL)
   {
@@ -1297,9 +1301,9 @@
     return NULL;
   }
 
-  if ((task_shell= gearman_task_internal_create(*client, task_shell)) == NULL)
+  if ((task_shell= gearman_task_internal_create(client, task_shell)) == NULL)
   {
-    *ret_ptr= gearman_client_error_code(client);
+    *ret_ptr= gearman_client_error_code(client_shell);
     return NULL;
   }
 
@@ -1311,14 +1315,14 @@
 
   args[0]= task->unique;
   args_size[0]= task->unique_length;
-  gearman_return_t rc= gearman_packet_create_args(client->impl()->universal, task->send,
+  gearman_return_t rc= gearman_packet_create_args(client->universal, task->send,
                                                   GEARMAN_MAGIC_REQUEST,
                                                   GEARMAN_COMMAND_GET_STATUS_UNIQUE,
                                                   args, args_size, 1);
   if (gearman_success(rc))
   {
-    client->impl()->new_tasks++;
-    client->impl()->running_tasks++;
+    client->new_tasks++;
+    client->running_tasks++;
     task->options.send_in_use= true;
   }
   *ret_ptr= rc;
 
=== modified file 'libgearman/do.cc'
--- libgearman/do.cc	2013-01-28 23:44:49 +0000
+++ libgearman/do.cc	2013-07-07 00:33:27 +0000
@@ -71,14 +71,14 @@
     ret_ptr= &unused;
   }
 
-  if (client == NULL)
+  if (client == NULL or client->impl() == NULL)
   {
     *ret_ptr= GEARMAN_INVALID_ARGUMENT;
     return NULL;
   }
 
   {
-    gearman_task_st *do_task_ptr= add_task(*client, &do_task, NULL, command,
+    gearman_task_st *do_task_ptr= add_task(*(client->impl()), &do_task, NULL, command,
                                            function,
                                            local_unique,
                                            workload,
@@ -144,14 +144,14 @@
                                       gearman_string_t &workload,
                                       gearman_job_handle_t job_handle)
 {
-  if (client == NULL)
+  if (client == NULL or client->impl() == NULL)
   {
     return GEARMAN_INVALID_ARGUMENT;
   }
 
   gearman_task_st do_task;
   {
-    gearman_task_st *do_task_ptr= add_task(*client, &do_task, 
+    gearman_task_st *do_task_ptr= add_task(*(client->impl()), &do_task, 
                                            client, 
                                            command,
                                            function,
 
=== modified file 'libgearman/execute.cc'
--- libgearman/execute.cc	2013-05-11 11:15:03 +0000
+++ libgearman/execute.cc	2013-07-07 00:33:27 +0000
@@ -70,18 +70,20 @@
 
 
 
-gearman_task_st *gearman_execute(gearman_client_st *client,
+gearman_task_st *gearman_execute(gearman_client_st *client_shell,
                                  const char *function_name, size_t function_length,
                                  const char *unique_str, size_t unique_length,
                                  gearman_task_attr_t *task_attr,
                                  gearman_argument_t *arguments,
                                  void *context)
 {
-  if (client == NULL)
+  if (client_shell == NULL or client_shell->impl() == NULL)
   {
     return NULL;
   }
 
+  Client* client= client_shell->impl();
+
   gearman_argument_t null_arg= gearman_argument_make(0, 0, 0, 0);
   if (arguments == NULL)
   {
@@ -90,7 +92,7 @@
 
   if (function_name == NULL or function_length == 0)
   {
-    gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "function_name was NULL");
+    gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "function_name was NULL");
     return NULL;
   }
   gearman_string_t function= { function_name, function_length };
@@ -149,18 +151,18 @@
 
   if (task == NULL)
   {
-    gearman_universal_error_code(client->impl()->universal);
+    gearman_universal_error_code(client->universal);
 
     return NULL;
   }
 
   task->impl()->type= GEARMAN_TASK_KIND_EXECUTE;
-  gearman_client_run_tasks(client);
+  gearman_client_run_tasks(client->shell());
 
   return task;
 }
 
-gearman_task_st *gearman_execute_by_partition(gearman_client_st *client,
+gearman_task_st *gearman_execute_by_partition(gearman_client_st *client_shell,
                                               const char *partition_function, const size_t partition_function_length,
                                               const char *function_name, const size_t function_name_length,
                                               const char *unique_str, const size_t unique_length,
@@ -168,25 +170,27 @@
                                               gearman_argument_t *arguments,
                                               void *context)
 {
-  if (client == NULL)
+  if (client_shell == NULL or client_shell->impl() == NULL)
   {
     errno= EINVAL;
     return NULL;
   }
 
+  Client* client= client_shell->impl();
+
   if ((partition_function == NULL) or (partition_function_length == 0))
   {
-    gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "partition_function was NULL");
+    gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "partition_function was NULL");
     return NULL;
   }
 
   if ((function_name == NULL) or (function_name_length == 0))
   {
-    gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "function_name was NULL");
+    gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "function_name was NULL");
     return NULL;
   }
   
-  universal_reset_error(client->impl()->universal);
+  universal_reset_error(client->universal);
 
   gearman_task_st *task= NULL;
   gearman_string_t partition= { partition_function, partition_function_length };
@@ -211,7 +215,7 @@
       break;
 
     case GEARMAN_TASK_ATTR_EPOCH:
-      gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "EPOCH is not currently supported for gearman_client_execute_reduce()");
+      gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "EPOCH is not currently supported for gearman_client_execute_reduce()");
       return NULL;
 #if 0
       task= add_task(client,
@@ -262,9 +266,9 @@
 
   do {
     gearman_return_t rc;
-    if (gearman_failed(rc= gearman_client_run_tasks(client)))
+    if (gearman_failed(rc= gearman_client_run_tasks(client->shell())))
     {
-      gearman_gerror(client->impl()->universal, rc);
+      gearman_gerror(client->universal, rc);
       gearman_task_free(task);
       return NULL;
     }
 
=== modified file 'libgearman/interface/task.hpp'
--- libgearman/interface/task.hpp	2013-07-06 20:11:54 +0000
+++ libgearman/interface/task.hpp	2013-07-07 00:33:27 +0000
@@ -89,7 +89,7 @@
     return _shell;
   }
 
-  Task(gearman_client_st& client_, gearman_task_st* shell_) :
+  Task(Client* client_, gearman_task_st* shell_) :
     type(GEARMAN_TASK_KIND_ADD_TASK),
     state(GEARMAN_TASK_STATE_NEW),
     magic_(TASK_MAGIC),
@@ -97,13 +97,13 @@
     numerator(0),
     denominator(0),
     client_count(0),
-    client(client_.impl()),
+    client(client_),
     next(NULL),
     prev(NULL),
     context(NULL),
     con(NULL),
     recv(NULL),
-    func(client_.impl()->actions),
+    func(client_->actions),
     result_rc(GEARMAN_UNKNOWN_STATE),
     _result_ptr(NULL),
     unique_length(0),
@@ -125,14 +125,14 @@
 
     // Add the task to the client
     {
-      if (client_.impl()->task_list)
+      if (client_->task_list)
       {
-        client_.impl()->task_list->impl()->prev= _shell;
+        client_->task_list->impl()->prev= _shell;
       }
-      next= client_.impl()->task_list;
+      next= client_->task_list;
       prev= NULL;
-      client_.impl()->task_list= _shell;
-      client_.impl()->task_count++;
+      client_->task_list= _shell;
+      client_->task_count++;
     }
 
     _shell->impl(this);
 
=== modified file 'libgearman/job.cc'
--- libgearman/job.cc	2013-07-05 22:06:45 +0000
+++ libgearman/job.cc	2013-07-07 00:33:27 +0000
@@ -77,34 +77,35 @@
   bool init()
   {
     client= gearman_client_create(NULL);
-    if (not client)
-    {
-      return false;
-    }
-
-    if (universal._namespace)
-    {
-      gearman_client_set_namespace(client, 
-                                   gearman_string_value(universal._namespace),
-                                   gearman_string_length(universal._namespace));
-    }
-
-    for (gearman_connection_st *con= universal.con_list; con; con= con->next_connection())
-    {
-      if (gearman_failed(client->impl()->add_server(con->_host, con->_service)))
-      {
-        return false;
-      }
-    }
-
-    return true;
+    if (client)
+    {
+
+      if (universal._namespace)
+      {
+        gearman_client_set_namespace(client, 
+                                     gearman_string_value(universal._namespace),
+                                     gearman_string_length(universal._namespace));
+      }
+
+      for (gearman_connection_st *con= universal.con_list; con; con= con->next_connection())
+      {
+        if (gearman_failed(client->impl()->add_server(con->_host, con->_service)))
+        {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    return false;
   }
 
   bool add(gearman_argument_t &arguments)
   {
     gearman_string_t function= gearman_string(reducer_function);
     gearman_unique_t unique= gearman_unique_make(0, 0);
-    gearman_task_st *task= add_task(*client,
+    gearman_task_st *task= add_task(*(client->impl()),
                                     NULL,
                                     GEARMAN_COMMAND_SUBMIT_JOB,
                                     function,
 
=== modified file 'libgearman/task.cc'
--- libgearman/task.cc	2013-07-06 17:53:34 +0000
+++ libgearman/task.cc	2013-07-07 00:33:27 +0000
@@ -54,7 +54,7 @@
  * Public Definitions
  */
 
-gearman_task_st *gearman_task_internal_create(gearman_client_st& client, gearman_task_st *task_shell)
+gearman_task_st *gearman_task_internal_create(Client* client, gearman_task_st *task_shell)
 {
   Task* task= new (std::nothrow) Task(client, task_shell);
   if (task)
@@ -62,7 +62,7 @@
     return task->shell();
   }
 
-  gearman_perror(client.impl()->universal, "gearman_task_st new");
+  gearman_perror(client->universal, "gearman_task_st new");
   gearman_task_free(task_shell);
 
   return NULL;
 
=== modified file 'libgearman/task.hpp'
--- libgearman/task.hpp	2013-07-06 17:53:34 +0000
+++ libgearman/task.hpp	2013-07-07 00:33:27 +0000
@@ -46,7 +46,7 @@
  * @return On success, a pointer to the (possibly allocated) structure. On
  *  failure this will be NULL.
  */
-gearman_task_st *gearman_task_internal_create(gearman_client_st& client,
+gearman_task_st *gearman_task_internal_create(Client* client,
                                               gearman_task_st *task);
 
 void gearman_task_free(Task* task);