Merge lp:~tangent-org/gearmand/build into lp:gearmand/1.0

[Brian Aker]

=== modified file 'ChangeLog'
--- ChangeLog	2012-09-19 07:36:20 +0000
+++ ChangeLog	2012-09-20 02:21:22 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 0.39 Wed Sep 19 03:36:06 EDT 2012
 * Added gearman_job_error() interface.
 * gearman_client_errno() and gearman_worker_errno() now return EINVAL if client or worker is invalid.
@@ -6,6 +7,11 @@
 * Updates for compiling on different platforms.
 * UUID portability fixes.
 
+=======
+1.0
+* Fix for ABI compatibility issues.
+
+>>>>>>> MERGE-SOURCE
 0.37 Sun Sep  2 22:51:08 EDT 2012
 * Fix compiler issues around older compilers. Bug 1039629.
 

=== modified file 'bin/client.h'
--- bin/client.h	2011-04-28 17:46:16 +0000
+++ bin/client.h	2012-09-20 02:21:22 +0000
@@ -37,6 +37,8 @@
 
 #pragma once
 
+namespace bin {
+
 class Client
 {
 public:
@@ -63,3 +65,5 @@
 private:
   gearman_client_st _client;
 };
+
+} // namespace bin

=== modified file 'bin/gearman.cc'
--- bin/gearman.cc	2012-07-12 00:08:17 +0000
+++ bin/gearman.cc	2012-09-20 02:21:22 +0000
@@ -237,7 +237,7 @@
 
 void _client(Args &args)
 {
-  Client local_client;
+  bin::Client local_client;
   gearman_client_st &client= local_client.client();
   Bytes workload;
   if (args.timeout() >= 0)
@@ -482,7 +482,7 @@
 
 void _worker(Args &args)
 {
-  Worker local_worker;
+  bin::Worker local_worker;
   gearman_worker_st &worker= local_worker.worker();
 
   if (args.timeout() >= 0)

=== modified file 'bin/worker.h'
--- bin/worker.h	2011-04-28 17:46:16 +0000
+++ bin/worker.h	2012-09-20 02:21:22 +0000
@@ -37,6 +37,8 @@
 
 #pragma once
 
+namespace bin {
+
 class Worker
 {
 public:
@@ -63,3 +65,4 @@
 private:
   gearman_worker_st _worker;
 };
+} //namespace bin

=== modified file 'configure.ac'
--- configure.ac	2012-09-19 21:51:59 +0000
+++ configure.ac	2012-09-20 02:21:22 +0000
@@ -6,7 +6,11 @@
 # Use and distribution licensed under the BSD license.  See
 # the COPYING file in this directory for full text.
 
+<<<<<<< TREE
 AC_INIT([gearmand],[0.39],[https://bugs.launchpad.net/gearmand],[gearmand],[http://gearman.info/])
+=======
+AC_INIT([gearmand],[1.0],[https://bugs.launchpad.net/gearmand],[gearmand],[http://gearman.info/])
+>>>>>>> MERGE-SOURCE
 AC_CONFIG_AUX_DIR([config])
 AC_CONFIG_MACRO_DIR([m4])
 
@@ -21,7 +25,7 @@
 AC_CONFIG_HEADERS([config.h:config.in])dnl Keep filename to 8.3 for MS-DOS.
 AC_CONFIG_SRCDIR(libgearman/gearman.cc)
 
-GEARMAN_LIBRARY_VERSION=7:0:0
+GEARMAN_LIBRARY_VERSION=8:0:0
 #                       | | |
 #                +------+ | +---+
 #                |        |     |

=== modified file 'libgearman-1.0/client.h'
--- libgearman-1.0/client.h	2012-06-28 01:28:50 +0000
+++ libgearman-1.0/client.h	2012-09-20 02:21:22 +0000
@@ -43,6 +43,8 @@
 
 #pragma once
 
+#include <libgearman-1.0/interface/client.h>
+
 /** @addtogroup gearman_client Client Declarations
  *
  * This is the interface gearman clients should use. You can run tasks one at a
@@ -59,32 +61,6 @@
   GEARMAN_CLIENT_STATE_PACKET
 };
 
-/**
- * @ingroup gearman_client
- */
-struct gearman_client_st
-{
-  struct {
-    bool allocated;
-    bool non_blocking;
-    bool unbuffered_result;
-    bool no_new;
-    bool free_tasks;
-  } options;
-  enum gearman_client_t state;
-  uint32_t new_tasks;
-  uint32_t running_tasks;
-  uint32_t task_count;
-  void *context;
-  gearman_connection_st *con;
-  gearman_task_st *task;
-  gearman_task_st *task_list;
-  gearman_task_context_free_fn *task_context_free_fn;
-  struct gearman_universal_st universal;
-  struct gearman_actions_t actions;
-  gearman_job_handle_t _do_handle; // Backwards compatible
-};
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -740,6 +716,9 @@
 
 const char *gearman_client_namespace(gearman_client_st *self);
 
+GEARMAN_API
+bool gearman_client_has_tasks(const gearman_client_st *client);
+
 /** @} */
 
 #ifdef __cplusplus

=== modified file 'libgearman-1.0/constants.h'
--- libgearman-1.0/constants.h	2012-05-27 00:47:14 +0000
+++ libgearman-1.0/constants.h	2012-09-20 02:21:22 +0000
@@ -133,7 +133,6 @@
 } gearman_worker_options_t;
 
 /* Types. */
-typedef struct gearman_packet_st gearman_packet_st;
 typedef struct gearman_task_st gearman_task_st;
 typedef struct gearman_client_st gearman_client_st;
 typedef struct gearman_job_st gearman_job_st;

=== modified file 'libgearman-1.0/core.h'
--- libgearman-1.0/core.h	2012-08-13 08:16:56 +0000
+++ libgearman-1.0/core.h	2012-09-20 02:21:22 +0000
@@ -39,5 +39,3 @@
 #pragma once
 
 #include <libgearman-1.0/allocator.h>
-#include <libgearman-1.0/universal.h>
-#include <libgearman-1.0/packet.h>

=== modified file 'libgearman-1.0/include.am'
--- libgearman-1.0/include.am	2012-07-05 18:59:46 +0000
+++ libgearman-1.0/include.am	2012-09-20 02:21:22 +0000
@@ -4,8 +4,10 @@
 
 include libgearman-1.0/t/include.am
 
+nobase_include_HEADERS+= libgearman-1.0/interface/client.h
 nobase_include_HEADERS+= libgearman-1.0/interface/status.h
 nobase_include_HEADERS+= libgearman-1.0/interface/task.h
+nobase_include_HEADERS+= libgearman-1.0/interface/worker.h
 nobase_include_HEADERS+= libgearman-1.0/status.h
 nobase_include_HEADERS+= \
 			 libgearman-1.0/actions.h \
@@ -26,7 +28,6 @@
 			 libgearman-1.0/kill.h \
 			 libgearman-1.0/limits.h \
 			 libgearman-1.0/ostream.hpp \
-			 libgearman-1.0/packet.h \
 			 libgearman-1.0/parse.h \
 			 libgearman-1.0/priority.h \
 			 libgearman-1.0/protocol.h \
@@ -37,7 +38,6 @@
 			 libgearman-1.0/string.h \
 			 libgearman-1.0/task.h \
 			 libgearman-1.0/task_attr.h \
-			 libgearman-1.0/universal.h \
 			 libgearman-1.0/util.h \
 			 libgearman-1.0/version.h \
 			 libgearman-1.0/visibility.h \

=== added file 'libgearman-1.0/interface/client.h'
--- libgearman-1.0/interface/client.h	1970-01-01 00:00:00 +0000
+++ libgearman-1.0/interface/client.h	2012-09-20 02:21:22 +0000
@@ -0,0 +1,62 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Gearmand client and server library.
+ *
+ *  Copyright (C) 2012 Data Differential, http://datadifferential.com/
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+struct Client;
+#endif
+
+struct gearman_client_st
+{
+  struct {
+    bool is_allocated;
+    bool is_initialized;
+  } options;
+  void *_impl;
+#ifdef __cplusplus
+  struct Client* impl() const
+  {
+    return (Client*)(_impl);
+  }
+
+  void impl(Client* impl_)
+  {
+    _impl= impl_;
+  }
+#endif
+};

=== modified file 'libgearman-1.0/interface/task.h'
--- libgearman-1.0/interface/task.h	2012-07-09 09:07:43 +0000
+++ libgearman-1.0/interface/task.h	2012-09-20 02:21:22 +0000
@@ -58,35 +58,26 @@
   GEARMAN_TASK_KIND_DO
 };
 
+#ifdef __cplusplus
+struct Task;
+#endif
+
 struct gearman_task_st
 {
   struct {
-    bool allocated;
-    bool send_in_use;
-    bool is_known;
-    bool is_running;
-    bool was_reduced;
-    bool is_paused;
+    bool is_allocated;
     bool is_initialized;
   } options;
-  enum gearman_task_kind_t type;
-  enum gearman_task_state_t state;
-  uint32_t magic_;
-  uint32_t created_id;
-  uint32_t numerator;
-  uint32_t denominator;
-  uint32_t client_count;
-  gearman_client_st *client;
-  gearman_task_st *next;
-  gearman_task_st *prev;
-  void *context;
-  gearman_connection_st *con;
-  gearman_packet_st *recv;
-  gearman_packet_st send;
-  struct gearman_actions_t func;
-  gearman_return_t result_rc;
-  struct gearman_result_st *result_ptr;
-  char job_handle[GEARMAN_JOB_HANDLE_SIZE];
-  size_t unique_length;
-  char unique[GEARMAN_MAX_UNIQUE_SIZE];
+  void *_impl;
+#ifdef __cplusplus
+  struct Task* impl() const
+  {
+    return (Task*)(_impl);
+  }
+
+  void impl(Task* impl_)
+  {
+    _impl= impl_;
+  }
+#endif
 };

=== added file 'libgearman-1.0/interface/worker.h'
--- libgearman-1.0/interface/worker.h	1970-01-01 00:00:00 +0000
+++ libgearman-1.0/interface/worker.h	2012-09-20 02:21:22 +0000
@@ -0,0 +1,63 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Gearmand client and server library.
+ *
+ *  Copyright (C) 2012 Data Differential, http://datadifferential.com/
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+struct Worker;
+#endif
+
+struct gearman_worker_st
+{
+  struct {
+    bool is_allocated;
+    bool is_initialized;
+  } options;
+  void *_impl;
+#ifdef __cplusplus
+  struct Worker* impl() const
+  {
+    return (Worker*)(_impl);
+  }
+
+  void impl(Worker* impl_)
+  {
+    _impl= impl_;
+  }
+#endif
+};
+

=== modified file 'libgearman-1.0/job.h'
--- libgearman-1.0/job.h	2012-09-16 00:30:28 +0000
+++ libgearman-1.0/job.h	2012-09-20 02:21:22 +0000
@@ -43,24 +43,6 @@
 
 #pragma once
 
-struct gearman_job_st
-{
-  struct {
-    bool allocated;
-    bool assigned_in_use;
-    bool work_in_use;
-    bool finished;
-  } options;
-  gearman_worker_st *worker;
-  gearman_job_st *next;
-  gearman_job_st *prev;
-  gearman_connection_st *con;
-  gearman_packet_st assigned;
-  gearman_packet_st work;
-  struct gearman_job_reducer_st *reducer;
-  gearman_return_t error_code;
-};
-
 #ifdef __cplusplus
 extern "C" {
 #endif

=== modified file 'libgearman-1.0/task_attr.h'
--- libgearman-1.0/task_attr.h	2012-04-15 21:57:52 +0000
+++ libgearman-1.0/task_attr.h	2012-09-20 02:21:22 +0000
@@ -66,7 +66,8 @@
 extern "C" {
 #endif
 
-#define  gearman_next(X) (X) ? (X)->next : NULL
+GEARMAN_API
+  gearman_task_st *gearman_next(gearman_task_st *task);
 
 GEARMAN_API
   gearman_task_attr_t gearman_task_attr_init(gearman_job_priority_t priority);

=== modified file 'libgearman-1.0/util.h'
--- libgearman-1.0/util.h	2011-11-03 07:35:45 +0000
+++ libgearman-1.0/util.h	2012-09-20 02:21:22 +0000
@@ -50,7 +50,7 @@
 GEARMAN_API
 const char *gearman_verbose_name(gearman_verbose_t verbose);
 
-#define gearman_timeout(__object) ((__object)->universal.timeout)
+#define gearman_timeout(__object) ((__object)->impl()->universal.timeout)
 
 #define gearman_set_timeout(__object, __value) ((__object)->universal.timeout)=(__value);
 

=== modified file 'libgearman-1.0/worker.h'
--- libgearman-1.0/worker.h	2012-06-28 01:28:50 +0000
+++ libgearman-1.0/worker.h	2012-09-20 02:21:22 +0000
@@ -43,6 +43,8 @@
 
 #pragma once
 
+#include <libgearman-1.0/interface/worker.h>
+
 /** @addtogroup gearman_worker Worker Declarations
  *
  * This is the interface gearman workers should use.
@@ -67,39 +69,6 @@
     GEARMAN_WORKER_WORK_UNIVERSAL_FAIL
   };
 
-/**
- * @ingroup gearman_worker
- */
-struct gearman_worker_st
-{
-  struct {
-    bool allocated;
-    bool non_blocking;
-    bool packet_init;
-    bool change;
-    bool grab_uniq;
-    bool grab_all;
-    bool timeout_return;
-  } options;
-  enum gearman_worker_state_t state;
-  enum gearman_worker_universal_t work_state;
-  uint32_t function_count;
-  uint32_t job_count;
-  size_t work_result_size;
-  void *context;
-  gearman_connection_st *con;
-  gearman_job_st *job;
-  gearman_job_st *job_list;
-  struct _worker_function_st *function;
-  struct _worker_function_st *function_list;
-  struct _worker_function_st *work_function;
-  void *work_result;
-  struct gearman_universal_st universal;
-  gearman_packet_st grab_job;
-  gearman_packet_st pre_sleep;
-  gearman_job_st *work_job;
-};
-
 #ifdef __cplusplus
 #define gearman_has_reducer(A) (A) ? static_cast<bool>((A)->reducer.final_fn) : false
 #else

=== modified file 'libgearman/actions.cc'
--- libgearman/actions.cc	2012-08-02 05:44:19 +0000
+++ libgearman/actions.cc	2012-09-20 02:21:22 +0000
@@ -47,27 +47,28 @@
 
 struct gearman_result_st;
 
-static gearman_return_t _client_pause_data(gearman_task_st *task)
+static gearman_return_t _client_pause_data(gearman_task_st* shell)
 {
+  Task* task= shell->impl();
   if (task->options.is_paused)
   {
     task->options.is_paused= false;
     return GEARMAN_SUCCESS;
   }
 
-  if (gearman_task_data_size(task))
+  if (gearman_task_data_size(shell))
   {
-    if (gearman_task_result(task))
+    if (gearman_task_result(shell))
     {
-      gearman_task_result(task)->clear();
+      gearman_task_result(shell)->clear();
     }
     else
     {
-      task->result_ptr= new (std::nothrow) gearman_result_st(gearman_task_data_size(task));
+      task->result_ptr= new (std::nothrow) gearman_result_st(gearman_task_data_size(shell));
     }
     assert_msg(task->result_ptr, "programmer error, result_ptr has not been allocated for task");
 
-    gearman_string_append(gearman_task_mutable_result(task)->string(), static_cast<const char*>(gearman_task_data(task)), gearman_task_data_size(task));
+    gearman_string_append(gearman_task_mutable_result(shell)->string(), static_cast<const char*>(gearman_task_data(shell)), gearman_task_data_size(shell));
   }
 
   if (task->recv->command == GEARMAN_COMMAND_WORK_DATA)
@@ -92,8 +93,9 @@
 }
 
 
-static gearman_return_t _client_pause_status(gearman_task_st *task)
+static gearman_return_t _client_pause_status(gearman_task_st* shell)
 {
+  Task* task= shell->impl();
   assert_msg(task->recv->command == GEARMAN_COMMAND_WORK_STATUS or
              task->recv->command == GEARMAN_COMMAND_STATUS_RES_UNIQUE or
              task->recv->command == GEARMAN_COMMAND_STATUS_RES, "status has been called out of order for task, or was registered to run on non-status callback, see gearman_actions_t(3)");
@@ -107,8 +109,9 @@
   return GEARMAN_PAUSE;
 }
 
-static gearman_return_t _client_pause_fail(gearman_task_st *task)
+static gearman_return_t _client_pause_fail(gearman_task_st* shell)
 {
+  Task* task= shell->impl();
   assert_msg(task->recv->command == GEARMAN_COMMAND_WORK_FAIL, 
              "fail callback has been called out of order for task, or was registered to run on non-fail callback, see gearman_actions_t(3)");
   if (task->options.is_paused)
@@ -121,39 +124,43 @@
   return GEARMAN_PAUSE;
 }
 
-static gearman_return_t _client_do_data(gearman_task_st *task)
+static gearman_return_t _client_do_data(gearman_task_st* shell)
 {
-  if (gearman_task_data_size(task))
+  Task* task= shell->impl();
+
+  if (gearman_task_data_size(shell))
   {
-    if (gearman_task_result(task) == NULL)
+    if (gearman_task_result(shell) == NULL)
     {
-      task->result_ptr= new (std::nothrow) gearman_result_st(gearman_task_data_size(task));
+      task->result_ptr= new (std::nothrow) gearman_result_st(gearman_task_data_size(shell));
       if (task->result_ptr == NULL)
       {
         return GEARMAN_MEMORY_ALLOCATION_FAILURE;
       }
     }
 
-    gearman_string_append(gearman_task_mutable_result(task)->string(), static_cast<const char*>(gearman_task_data(task)), gearman_task_data_size(task));
+    gearman_string_append(gearman_task_mutable_result(shell)->string(), static_cast<const char*>(gearman_task_data(shell)), gearman_task_data_size(shell));
   }
 
   return GEARMAN_SUCCESS;
 }
 
-static gearman_return_t _client_do_complete(gearman_task_st *task)
+static gearman_return_t _client_do_complete(gearman_task_st *shell)
 {
-  if (gearman_task_data_size(task))
+  Task* task= shell->impl();
+
+  if (gearman_task_data_size(shell))
   {
-    if (gearman_task_result(task) == NULL)
+    if (gearman_task_result(shell) == NULL)
     {
-      task->result_ptr= new (std::nothrow) gearman_result_st(gearman_task_data_size(task));
+      task->result_ptr= new (std::nothrow) gearman_result_st(gearman_task_data_size(shell));
       if (task->result_ptr == NULL)
       {
         return GEARMAN_MEMORY_ALLOCATION_FAILURE;
       }
     }
 
-    gearman_string_append(gearman_task_mutable_result(task)->string(), static_cast<const char*>(gearman_task_data(task)), gearman_task_data_size(task));
+    gearman_string_append(gearman_task_mutable_result(shell)->string(), static_cast<const char*>(gearman_task_data(shell)), gearman_task_data_size(shell));
   }
 
   task->result_rc= GEARMAN_SUCCESS;

=== modified file 'libgearman/actions.hpp'
--- libgearman/actions.hpp	2012-08-13 08:16:56 +0000
+++ libgearman/actions.hpp	2012-09-20 02:21:22 +0000
@@ -39,17 +39,13 @@
 
 #ifdef __cplusplus // Local only
 
-GEARMAN_LOCAL
 const gearman_actions_t &gearman_actions_default();
 
-GEARMAN_LOCAL
 const gearman_actions_t &gearman_actions_do_default();
 
-GEARMAN_LOCAL
 const gearman_actions_t &gearman_actions_execute_defaults();
 
 GEARMAN_API
 const gearman_actions_t &gearman_actions_pause();
 
 #endif
-

=== modified file 'libgearman/add.cc'
--- libgearman/add.cc	2012-09-12 09:17:38 +0000
+++ libgearman/add.cc	2012-09-20 02:21:22 +0000
@@ -89,7 +89,7 @@
   task= add_task(client, task, context, command, function, local_unique, workload, when, actions);
   if (task == NULL)
   {
-    *ret_ptr= gearman_universal_error_code(client.universal);
+    *ret_ptr= client.impl()->universal.error_code();
     return NULL;
   }
 
@@ -99,7 +99,7 @@
 }
 
 gearman_task_st *add_task(gearman_client_st& client,
-                          gearman_task_st *task,
+                          gearman_task_st *task_shell,
                           void *context,
                           gearman_command_t command,
                           const gearman_string_t &function,
@@ -112,11 +112,11 @@
   {
     if (gearman_size(function) > GEARMAN_FUNCTION_MAX_SIZE)
     {
-      gearman_error(client.universal, GEARMAN_INVALID_ARGUMENT, "function name longer then GEARMAN_MAX_FUNCTION_SIZE");
+      gearman_error(client.impl()->universal, GEARMAN_INVALID_ARGUMENT, "function name longer then GEARMAN_MAX_FUNCTION_SIZE");
     } 
     else
     {
-      gearman_error(client.universal, GEARMAN_INVALID_ARGUMENT, "invalid function");
+      gearman_error(client.impl()->universal, GEARMAN_INVALID_ARGUMENT, "invalid function");
     }
 
     return NULL;
@@ -124,23 +124,27 @@
 
   if (gearman_size(unique) > GEARMAN_MAX_UNIQUE_SIZE)
   {
-    gearman_error(client.universal, GEARMAN_INVALID_ARGUMENT, "unique name longer then GEARMAN_MAX_UNIQUE_SIZE");
+    gearman_error(client.impl()->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.universal, GEARMAN_INVALID_ARGUMENT, "invalid workload");
+    gearman_error(client.impl()->universal, GEARMAN_INVALID_ARGUMENT, "invalid workload");
     return NULL;
   }
 
-  task= gearman_task_internal_create(&client, task);
-  if (task == NULL)
+  task_shell= gearman_task_internal_create(client, task_shell);
+  if (task_shell == NULL or task_shell->impl() == NULL)
   {
-    gearman_error(client.universal, GEARMAN_MEMORY_ALLOCATION_FAILURE, "");
+    gearman_error(client.impl()->universal, GEARMAN_MEMORY_ALLOCATION_FAILURE, "");
     return NULL;
   }
+  assert(task_shell->impl()->client);
+  assert(task_shell->impl()->client == &client);
+
+  Task* task= task_shell->impl();
 
   task->context= context;
   task->func= actions;
@@ -239,14 +243,14 @@
 
   if (gearman_success(rc))
   {
-    client.new_tasks++;
-    client.running_tasks++;
+    client.impl()->new_tasks++;
+    client.impl()->running_tasks++;
     task->options.send_in_use= true;
 
-    return task;
+    return task->shell();
   }
 
-  gearman_task_free(task);
+  gearman_task_free(task->shell());
 
   return NULL;
 }
@@ -269,11 +273,11 @@
   {
     if (gearman_size(function) > GEARMAN_FUNCTION_MAX_SIZE)
     {
-      gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "function name longer then GEARMAN_MAX_FUNCTION_SIZE");
+      gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "function name longer then GEARMAN_MAX_FUNCTION_SIZE");
     } 
     else
     {
-      gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "invalid function");
+      gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "invalid function");
     }
 
     return NULL;
@@ -281,36 +285,36 @@
 
   if (gearman_size(unique) > GEARMAN_MAX_UNIQUE_SIZE)
   {
-    gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "unique name longer then GEARMAN_MAX_UNIQUE_SIZE");
+    gearman_error(client->impl()->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->universal, GEARMAN_INVALID_ARGUMENT, "invalid workload");
+    gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "invalid workload");
     return NULL;
   }
 
-  gearman_task_st *task= gearman_task_internal_create(client, NULL);
+  gearman_task_st *task= gearman_task_internal_create(*client, NULL);
   if (task == NULL)
   {
-    gearman_error(client->universal, GEARMAN_MEMORY_ALLOCATION_FAILURE, "");
+    gearman_error(client->impl()->universal, GEARMAN_MEMORY_ALLOCATION_FAILURE, "");
     return NULL;
   }
 
-  task->context= context;
-  task->func= actions;
+  task->impl()->context= context;
+  task->impl()->func= actions;
 
   /**
     @todo fix it so that NULL is done by default by the API not by happenstance.
   */
   char function_buffer[1024];
-  if (client->universal._namespace)
+  if (client->impl()->universal._namespace)
   {
     char *ptr= function_buffer;
-    memcpy(ptr, gearman_string_value(client->universal._namespace), gearman_string_length(client->universal._namespace)); 
-    ptr+= gearman_string_length(client->universal._namespace);
+    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_c_str(function), gearman_size(function) +1);
     ptr+= gearman_size(function);
@@ -326,6 +330,7 @@
 
   if ((task->unique_length= gearman_size(unique)))
   {
+<<<<<<< TREE
     if (task->unique_length >= GEARMAN_MAX_UNIQUE_SIZE)
     {
       task->unique_length= GEARMAN_MAX_UNIQUE_SIZE -1; // Leave space for NULL byte
@@ -333,10 +338,23 @@
 
     strncpy(task->unique, gearman_c_str(unique), GEARMAN_MAX_UNIQUE_SIZE);
     task->unique[task->unique_length]= 0;
+=======
+    args[1]= gearman_c_str(unique);
+    args_size[1]= gearman_size(unique) + 1;
+    strncpy(task->impl()->unique, gearman_c_str(unique), gearman_size(unique));
+>>>>>>> MERGE-SOURCE
   }
   else
   {
+<<<<<<< TREE
     safe_uuid_generate(task->unique, task->unique_length);
+=======
+    safe_uuid_generate(uuid);
+    uuid_unparse(uuid, task->impl()->unique);
+    task->impl()->unique[GEARMAN_MAX_UUID_SIZE]= 0;
+    args[1]= task->impl()->unique;
+    args_size[1]= GEARMAN_MAX_UUID_SIZE +1; // +1 is for the needed null
+>>>>>>> MERGE-SOURCE
   }
 
   args[1]= task->unique;
@@ -346,11 +364,11 @@
              "Command was not appropriate for request");
 
   char reducer_buffer[1024];
-  if (client->universal._namespace)
+  if (client->impl()->universal._namespace)
   {
     char *ptr= reducer_buffer;
-    memcpy(ptr, gearman_string_value(client->universal._namespace), gearman_string_length(client->universal._namespace)); 
-    ptr+= gearman_string_length(client->universal._namespace);
+    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_c_str(reducer), gearman_size(reducer) +1);
     ptr+= gearman_size(reducer);
@@ -375,22 +393,22 @@
   args_size[4]= gearman_size(workload);
 
   gearman_return_t rc;
-  if (gearman_success(rc= gearman_packet_create_args(client->universal, task->send,
+  if (gearman_success(rc= gearman_packet_create_args(client->impl()->universal, task->impl()->send,
                                                      GEARMAN_MAGIC_REQUEST, command,
                                                      args, args_size,
                                                      5)))
   {
-    client->new_tasks++;
-    client->running_tasks++;
-    task->options.send_in_use= true;
+    client->impl()->new_tasks++;
+    client->impl()->running_tasks++;
+    task->impl()->options.send_in_use= true;
   }
   else
   {
-    gearman_gerror(client->universal, rc);
+    gearman_gerror(client->impl()->universal, rc);
     gearman_task_free(task);
     task= NULL;
   }
-  task->type= GEARMAN_TASK_KIND_EXECUTE;
+  task->impl()->type= GEARMAN_TASK_KIND_EXECUTE;
 
   return task;
 }

=== modified file 'libgearman/allocator.hpp'
--- libgearman/allocator.hpp	2011-06-21 09:48:26 +0000
+++ libgearman/allocator.hpp	2012-09-20 02:21:22 +0000
@@ -36,29 +36,26 @@
 
 #pragma once
 
-GEARMAN_LOCAL
+#include <libgearman-1.0/allocator.h>
+
 void *gearman_real_malloc(gearman_allocator_t& allocator, size_t size, const char *func, const char *file, int line);
 
 #define gearman_malloc(__gearman_universal_st, __size) gearman_real_malloc(((__gearman_universal_st).allocator), (__size), __func__, __FILE__, __LINE__)
 
-GEARMAN_LOCAL
 void *gearman_real_calloc(gearman_allocator_t& allocator, size_t nelem, size_t size, const char *func, const char *file, int line);
 
 #define gearman_calloc(__gearman_universal_st, __nelem,  __size) gearman_real_calloc(((__gearman_universal_st).allocator), (__nelem), (__size), __func__, __FILE__, __LINE__)
 
-GEARMAN_LOCAL
 void *gearman_real_realloc(gearman_allocator_t&, void *ptr, size_t size, const char *func, const char *file, int line);
 
 #define gearman_realloc(__gearman_universal_st, __ptr, __size) gearman_real_realloc(((__gearman_universal_st).allocator), (__ptr), (__size), __func__, __FILE__, __LINE__)
 
-GEARMAN_LOCAL
 void gearman_real_free(gearman_allocator_t& allocator, void *ptr, const char *func, const char *file, int line);
 
 #define gearman_free(__gearman_universal_st, __ptr) gearman_real_free(((__gearman_universal_st).allocator), (__ptr), __func__, __FILE__, __LINE__)
 
 #define gearman_has_allocator(__gearman_universal_st) bool(__gearman_universal_st.allocator.malloc)
 
-GEARMAN_LOCAL
 gearman_return_t gearman_set_memory_allocator(gearman_allocator_t& allocator,
                                               gearman_malloc_fn *malloc_fn,
                                               gearman_free_fn *free_fn,
@@ -67,6 +64,5 @@
                                               void *context);
 
 
-GEARMAN_LOCAL
 gearman_allocator_t gearman_default_allocator();
 

=== modified file 'libgearman/client.cc'
--- libgearman/client.cc	2012-09-17 03:07:48 +0000
+++ libgearman/client.cc	2012-09-20 02:21:22 +0000
@@ -42,6 +42,7 @@
 #include <libgearman/log.hpp>
 
 #include "libgearman/assert.hpp"
+#include "libgearman/interface/push.hpp"
 
 #include <arpa/inet.h>
 #include <cerrno>
@@ -56,45 +57,23 @@
 /*
   Allocate a client structure.
  */
-static gearman_client_st *_client_allocate(gearman_client_st *client, bool is_clone)
+static gearman_client_st *_client_allocate(gearman_client_st *client_shell, bool is_clone)
 {
+  Client *client= new (std::nothrow) Client(client_shell);
   if (client)
   {
-    client->options.allocated= false;
-  }
-  else
-  {
-    client= new (std::nothrow) gearman_client_st;
-    if (client == NULL)
+    if (is_clone == false)
     {
-      return NULL;
+#if 0
+      gearman_universal_initialize(client_shell->impl()->universal);
+  gearman_universal_initialize(universal);
+#endif
     }
 
-    client->options.allocated= true;
-  }
-
-  client->options.non_blocking= false;
-  client->options.unbuffered_result= false;
-  client->options.no_new= false;
-  client->options.free_tasks= false;
-
-  client->state= GEARMAN_CLIENT_STATE_IDLE;
-  client->new_tasks= 0;
-  client->running_tasks= 0;
-  client->task_count= 0;
-  client->context= NULL;
-  client->con= NULL;
-  client->task= NULL;
-  client->task_list= NULL;
-  client->task_context_free_fn= NULL;
-  gearman_client_clear_fn(client);
-
-  if (is_clone == false)
-  {
-    gearman_universal_initialize(client->universal);
-  }
-
-  return client;
+    return client->shell();
+  }
+
+  return NULL;
 }
 
 /**
@@ -128,7 +107,7 @@
     return NULL;
   }
 
-  universal_reset_error(client->universal);
+  client->impl()->universal.reset_error();
 
   size_t unused_size;
   if (result_size == NULL)
@@ -142,23 +121,28 @@
   gearman_string_t workload= { static_cast<const char*>(workload_str), workload_size };
 
   gearman_task_st do_task;
-  gearman_task_st *do_task_ptr= add_task(*client, &do_task, NULL, command,
-                                         function,
-                                         local_unique,
-                                         workload,
-                                         time_t(0),
-                                         gearman_actions_do_default());
-  if (do_task_ptr == NULL)
   {
-    *ret_ptr= gearman_universal_error_code(client->universal);
-    return NULL;
+    gearman_task_st *do_task_ptr= add_task(*client, &do_task, NULL, command,
+                                           function,
+                                           local_unique,
+                                           workload,
+                                           time_t(0),
+                                           gearman_actions_do_default());
+    if (do_task_ptr == NULL)
+    {
+      *ret_ptr= client->impl()->universal.error_code();
+      return NULL;
+    }
+    assert_msg(do_task.impl(), "Bad return by add_task()");
+    assert_msg(&do_task == do_task_ptr, "Bad return by add_task()");
   }
-  do_task_ptr->type= GEARMAN_TASK_KIND_DO;
+
+  do_task.impl()->type= GEARMAN_TASK_KIND_DO;
 
   gearman_return_t ret= gearman_client_run_block_tasks(client);
 
   // gearman_client_run_tasks failed
-  assert(client->task_list); // Programmer error, we should always have the task that we used for do
+  assert(client->impl()->task_list); // Programmer error, we should always have the task that we used for do
 
   char *returnable= NULL;
   if (gearman_failed(ret))
@@ -167,24 +151,24 @@
     { }
     else
     {
-      gearman_error(client->universal, ret, "occured during gearman_client_run_tasks()");
+      gearman_error(client->impl()->universal, ret, "occured during gearman_client_run_tasks()");
     }
 
     *ret_ptr= ret;
     *result_size= 0;
   }
-  else if (gearman_success(ret) and do_task_ptr->result_rc == GEARMAN_SUCCESS)
+  else if (gearman_success(ret) and do_task.impl()->result_rc == GEARMAN_SUCCESS)
   {
-    *ret_ptr= do_task_ptr->result_rc;
-    if (gearman_task_result(do_task_ptr))
+    *ret_ptr= do_task.impl()->result_rc;
+    if (gearman_task_result(&do_task))
     {
-      if (gearman_has_allocator(client->universal))
+      if (gearman_has_allocator(client->impl()->universal))
       {
-        gearman_string_t result= gearman_result_string(do_task_ptr->result_ptr);
-        returnable= static_cast<char *>(gearman_malloc(client->universal, gearman_size(result) +1));
+        gearman_string_t result= gearman_result_string(do_task.impl()->result_ptr);
+        returnable= static_cast<char *>(gearman_malloc(client->impl()->universal, gearman_size(result) +1));
         if (returnable == NULL)
         {
-          gearman_error(client->universal, GEARMAN_MEMORY_ALLOCATION_FAILURE, "custom workload_fn failed to allocate memory");
+          gearman_error(client->impl()->universal, GEARMAN_MEMORY_ALLOCATION_FAILURE, "custom workload_fn failed to allocate memory");
           *result_size= 0;
         }
         else // NULL terminate
@@ -196,7 +180,7 @@
       }
       else
       {
-        gearman_string_t result= gearman_result_take_string(do_task_ptr->result_ptr);
+        gearman_string_t result= gearman_result_take_string(do_task.impl()->result_ptr);
         *result_size= gearman_size(result);
         returnable= const_cast<char *>(gearman_c_str(result));
       }
@@ -208,15 +192,15 @@
   }
   else // gearman_client_run_tasks() was successful, but the task was not
   {
-    gearman_error(client->universal, do_task_ptr->result_rc, "occured during gearman_client_run_tasks()");
+    gearman_error(client->impl()->universal, do_task.impl()->result_rc, "occured during gearman_client_run_tasks()");
 
-    *ret_ptr= do_task_ptr->result_rc;
+    *ret_ptr= do_task.impl()->result_rc;
     *result_size= 0;
   }
 
   gearman_task_free(&do_task);
-  client->new_tasks= 0;
-  client->running_tasks= 0;
+  client->impl()->new_tasks= 0;
+  client->impl()->running_tasks= 0;
 
   return returnable;
 }
@@ -236,39 +220,43 @@
     return GEARMAN_INVALID_ARGUMENT;
   }
 
-  universal_reset_error(client->universal);
+  client->impl()->universal.reset_error();
 
   if (gearman_size(function) == 0)
   {
-    return gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "function argument was empty");
+    return gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "function argument was empty");
   }
 
-  client->_do_handle[0]= 0; // Reset the job_handle we store in client
+  client->impl()->_do_handle[0]= 0; // Reset the job_handle we store in client
 
-  gearman_task_st do_task, *do_task_ptr;
-  do_task_ptr= add_task(*client, &do_task, 
-                        client, 
-                        command,
-                        function,
-                        unique,
-                        workload,
-                        time_t(0),
-                        gearman_actions_do_default());
-  if (not do_task_ptr)
+  gearman_task_st do_task;
   {
-    return gearman_universal_error_code(client->universal);
+    gearman_task_st* do_task_ptr= add_task(*client, &do_task, 
+                                           client, 
+                                           command,
+                                           function,
+                                           unique,
+                                           workload,
+                                           time_t(0),
+                                           gearman_actions_do_default());
+    if (do_task_ptr == NULL)
+    {
+      return client->impl()->universal.error_code();
+    }
+    assert(do_task_ptr);
+    assert(&do_task == do_task_ptr);
   }
-  do_task_ptr->type= GEARMAN_TASK_KIND_DO;
+  do_task.impl()->type= GEARMAN_TASK_KIND_DO;
 
   gearman_return_t ret= gearman_client_run_block_tasks(client);
 
   if (job_handle)
   {
-    strncpy(job_handle, do_task.job_handle, GEARMAN_JOB_HANDLE_SIZE);
+    strncpy(job_handle, do_task.impl()->job_handle, GEARMAN_JOB_HANDLE_SIZE);
   }
-  strncpy(client->_do_handle, do_task.job_handle, GEARMAN_JOB_HANDLE_SIZE);
-  client->new_tasks= 0;
-  client->running_tasks= 0;
+  strncpy(client->impl()->_do_handle, do_task.impl()->job_handle, GEARMAN_JOB_HANDLE_SIZE);
+  client->impl()->new_tasks= 0;
+  client->impl()->running_tasks= 0;
   gearman_task_free(&do_task);
 
   return ret;
@@ -284,59 +272,56 @@
   return _client_allocate(client, false);
 }
 
-gearman_client_st *gearman_client_clone(gearman_client_st *client,
-                                        const gearman_client_st *from)
-{
-  if (not from)
-  {
-    return _client_allocate(client, false);
-  }
-
-  client= _client_allocate(client, true);
-
-  if (client == NULL)
-  {
-    return client;
-  }
-
-  client->options.non_blocking= from->options.non_blocking;
-  client->options.unbuffered_result= from->options.unbuffered_result;
-  client->options.no_new= from->options.no_new;
-  client->options.free_tasks= from->options.free_tasks;
-  client->actions= from->actions;
-  client->_do_handle[0]= 0;
-
-  gearman_universal_clone(client->universal, from->universal);
-
-  return client;
-}
-
-void gearman_client_free(gearman_client_st *client)
-{
-  if (client)
-  {
-
-    gearman_client_task_free_all(client);
-
-    gearman_universal_free(client->universal);
-
-    if (client->options.allocated)
-    {
-      delete client;
-    }
-  }
-}
-
-const char *gearman_client_error(const gearman_client_st *client)
-{
-  if (client)
-  {
-    return gearman_universal_error(client->universal);
+gearman_client_st *gearman_client_clone(gearman_client_st *destination,
+                                        const gearman_client_st *source)
+{
+  if (source == NULL)
+  {
+    return _client_allocate(destination, false);
+  }
+
+  destination= _client_allocate(destination, true);
+
+  if (destination == NULL)
+  {
+    return destination;
+  }
+
+  destination->impl()->options.non_blocking= source->impl()->options.non_blocking;
+  destination->impl()->options.unbuffered_result= source->impl()->options.unbuffered_result;
+  destination->impl()->options.no_new= source->impl()->options.no_new;
+  destination->impl()->options.free_tasks= source->impl()->options.free_tasks;
+  destination->impl()->actions= source->impl()->actions;
+  destination->impl()->_do_handle[0]= 0;
+
+  gearman_universal_clone(destination->impl()->universal, source->impl()->universal);
+
+  return destination;
+}
+
+void gearman_client_free(gearman_client_st *client_shell)
+{
+  if (client_shell)
+  {
+    gearman_client_task_free_all(client_shell);
+
+    gearman_universal_free(client_shell->impl()->universal);
+
+    delete client_shell->impl();
+  }
+}
+
+const char *gearman_client_error(const gearman_client_st *client_shell)
+{
+  if (client_shell)
+  {
+    return client_shell->impl()->universal.error();
   }
 
   return NULL;
 }
 
+<<<<<<< TREE
 gearman_return_t gearman_client_error_code(const gearman_client_st *client)
 {
   if (client == NULL)
@@ -358,49 +343,72 @@
 }
 
 gearman_client_options_t gearman_client_options(const gearman_client_st *client)
+=======
+gearman_return_t gearman_client_error_code(const gearman_client_st *client_shell)
+{
+  if (client_shell)
+  {
+    return client_shell->impl()->universal.error_code();
+  }
+
+  return GEARMAN_INVALID_ARGUMENT;
+}
+
+int gearman_client_errno(const gearman_client_st *client_shell)
+{
+  if (client_shell)
+  {
+    return client_shell->impl()->universal.last_errno();
+  }
+
+  return 0;
+}
+
+gearman_client_options_t gearman_client_options(const gearman_client_st *client_shell)
+>>>>>>> MERGE-SOURCE
 {
   int32_t options;
   memset(&options, 0, sizeof(int32_t));
 
-  if (client->options.allocated)
+  if (gearman_is_allocated(client_shell))
     options|= int(GEARMAN_CLIENT_ALLOCATED);
 
-  if (client->options.non_blocking)
+  if (client_shell->impl()->options.non_blocking)
     options|= int(GEARMAN_CLIENT_NON_BLOCKING);
 
-  if (client->options.unbuffered_result)
+  if (client_shell->impl()->options.unbuffered_result)
     options|= int(GEARMAN_CLIENT_UNBUFFERED_RESULT);
 
-  if (client->options.no_new)
+  if (client_shell->impl()->options.no_new)
     options|= int(GEARMAN_CLIENT_NO_NEW);
 
-  if (client->options.free_tasks)
+  if (client_shell->impl()->options.free_tasks)
     options|= int(GEARMAN_CLIENT_FREE_TASKS);
 
   return gearman_client_options_t(options);
 }
 
-bool gearman_client_has_option(gearman_client_st *client,
+bool gearman_client_has_option(gearman_client_st *client_shell,
                                 gearman_client_options_t option)
 {
-  if (client)
+  if (client_shell and client_shell->impl())
   {
     switch (option)
     {
     case GEARMAN_CLIENT_ALLOCATED:
-      return client->options.allocated;
+      return gearman_is_allocated(client_shell);
 
     case GEARMAN_CLIENT_NON_BLOCKING:
-      return client->options.non_blocking;
+      return client_shell->impl()->options.non_blocking;
 
     case GEARMAN_CLIENT_UNBUFFERED_RESULT:
-      return client->options.unbuffered_result;
+      return client_shell->impl()->options.unbuffered_result;
 
     case GEARMAN_CLIENT_NO_NEW:
-      return client->options.no_new;
+      return client_shell->impl()->options.no_new;
 
     case GEARMAN_CLIENT_FREE_TASKS:
-      return client->options.free_tasks;
+      return client_shell->impl()->options.free_tasks;
 
     default:
     case GEARMAN_CLIENT_TASK_IN_USE:
@@ -412,10 +420,10 @@
   return false;
 }
 
-void gearman_client_set_options(gearman_client_st *client,
+void gearman_client_set_options(gearman_client_st *client_shell,
                                 gearman_client_options_t options)
 {
-  if (client)
+  if (client_shell)
   {
     gearman_client_options_t usable_options[]= {
       GEARMAN_CLIENT_NON_BLOCKING,
@@ -428,130 +436,130 @@
     {
       if (options & *ptr)
       {
-        gearman_client_add_options(client, *ptr);
+        gearman_client_add_options(client_shell, *ptr);
       }
       else
       {
-        gearman_client_remove_options(client, *ptr);
+        gearman_client_remove_options(client_shell, *ptr);
       }
     }
   }
 }
 
-void gearman_client_add_options(gearman_client_st *client,
+void gearman_client_add_options(gearman_client_st *client_shell,
                                 gearman_client_options_t options)
 {
-  if (client)
+  if (client_shell)
   {
     if (options & GEARMAN_CLIENT_NON_BLOCKING)
     {
-      gearman_universal_add_options(client->universal, GEARMAN_NON_BLOCKING);
-      client->options.non_blocking= true;
+      gearman_universal_add_options(client_shell->impl()->universal, GEARMAN_NON_BLOCKING);
+      client_shell->impl()->options.non_blocking= true;
     }
 
     if (options & GEARMAN_CLIENT_UNBUFFERED_RESULT)
     {
-      client->options.unbuffered_result= true;
+      client_shell->impl()->options.unbuffered_result= true;
     }
 
     if (options & GEARMAN_CLIENT_FREE_TASKS)
     {
-      client->options.free_tasks= true;
+      client_shell->impl()->options.free_tasks= true;
     }
   }
 }
 
-void gearman_client_remove_options(gearman_client_st *client,
+void gearman_client_remove_options(gearman_client_st *client_shell,
                                    gearman_client_options_t options)
 {
-  if (client)
+  if (client_shell)
   {
     if (options & GEARMAN_CLIENT_NON_BLOCKING)
     {
-      gearman_universal_remove_options(client->universal, GEARMAN_NON_BLOCKING);
-      client->options.non_blocking= false;
+      gearman_universal_remove_options(client_shell->impl()->universal, GEARMAN_NON_BLOCKING);
+      client_shell->impl()->options.non_blocking= false;
     }
 
     if (options & GEARMAN_CLIENT_UNBUFFERED_RESULT)
     {
-      client->options.unbuffered_result= false;
+      client_shell->impl()->options.unbuffered_result= false;
     }
 
     if (options & GEARMAN_CLIENT_FREE_TASKS)
     {
-      client->options.free_tasks= false;
+      client_shell->impl()->options.free_tasks= false;
     }
   }
 }
 
-int gearman_client_timeout(gearman_client_st *client)
+int gearman_client_timeout(gearman_client_st *client_shell)
 {
-  return gearman_universal_timeout(client->universal);
+  return gearman_universal_timeout(client_shell->impl()->universal);
 }
 
-void gearman_client_set_timeout(gearman_client_st *client, int timeout)
+void gearman_client_set_timeout(gearman_client_st *client_shell, int timeout)
 {
-  if (client)
+  if (client_shell)
   {
-    gearman_universal_set_timeout(client->universal, timeout);
+    gearman_universal_set_timeout(client_shell->impl()->universal, timeout);
   }
 }
 
-void *gearman_client_context(const gearman_client_st *client)
+void *gearman_client_context(const gearman_client_st *client_shell)
 {
-  if (client)
+  if (client_shell)
   {
-    return const_cast<void *>(client->context);
+    return const_cast<void *>(client_shell->impl()->context);
   }
 
   return NULL;
 }
 
-void gearman_client_set_context(gearman_client_st *client, void *context)
+void gearman_client_set_context(gearman_client_st *client_shell, void *context)
 {
-  if (client)
+  if (client_shell)
   {
-    client->context= context;
+    client_shell->impl()->context= context;
   }
 }
 
-void gearman_client_set_log_fn(gearman_client_st *client,
+void gearman_client_set_log_fn(gearman_client_st *client_shell,
                                gearman_log_fn *function, void *context,
                                gearman_verbose_t verbose)
 {
-  if (client)
+  if (client_shell)
   {
-    gearman_set_log_fn(client->universal, function, context, verbose);
+    gearman_set_log_fn(client_shell->impl()->universal, function, context, verbose);
   }
 }
 
-void gearman_client_set_workload_malloc_fn(gearman_client_st *client,
+void gearman_client_set_workload_malloc_fn(gearman_client_st *client_shell,
                                            gearman_malloc_fn *function,
                                            void *context)
 {
-  if (client)
+  if (client_shell)
   {
-    gearman_set_workload_malloc_fn(client->universal, function, context);
+    gearman_set_workload_malloc_fn(client_shell->impl()->universal, function, context);
   }
 }
 
-void gearman_client_set_workload_free_fn(gearman_client_st *client, gearman_free_fn *function, void *context)
+void gearman_client_set_workload_free_fn(gearman_client_st *client_shell, gearman_free_fn *function, void *context)
 {
-  if (client)
+  if (client_shell)
   {
-    gearman_set_workload_free_fn(client->universal, function, context);
+    gearman_set_workload_free_fn(client_shell->impl()->universal, function, context);
   }
 }
 
-gearman_return_t gearman_client_add_server(gearman_client_st *client,
+gearman_return_t gearman_client_add_server(gearman_client_st *client_shell,
                                            const char *host, in_port_t port)
 {
-  if (client)
+  if (client_shell)
   {
-    if (gearman_connection_create_args(client->universal, host, port) == false)
+    if (gearman_connection_create_args(client_shell->impl()->universal, host, port) == false)
     {
-      assert(client->universal.error.rc != GEARMAN_SUCCESS);
-      return gearman_universal_error_code(client->universal);
+      assert(client_shell->impl()->universal.error_code() != GEARMAN_SUCCESS);
+      return client_shell->impl()->universal.error_code();
     }
 
     return GEARMAN_SUCCESS;
@@ -560,81 +568,92 @@
   return GEARMAN_INVALID_ARGUMENT;
 }
 
-gearman_return_t gearman_client_add_servers(gearman_client_st *client,
+gearman_return_t Client::add_server(const char *host, const char* service_)
+{
+  if (gearman_connection_create_args(universal, host, service_) == false)
+  {
+    assert(universal.error_code() != GEARMAN_SUCCESS);
+    return universal.error_code();
+  }
+
+  return GEARMAN_SUCCESS;
+}
+
+gearman_return_t gearman_client_add_servers(gearman_client_st *client_shell,
                                             const char *servers)
 {
-  return gearman_parse_servers(servers, _client_add_server, client);
+  return gearman_parse_servers(servers, _client_add_server, client_shell);
 }
 
-void gearman_client_remove_servers(gearman_client_st *client)
+void gearman_client_remove_servers(gearman_client_st *client_shell)
 {
-  if (client)
+  if (client_shell)
   {
-    gearman_free_all_cons(client->universal);
+    gearman_free_all_cons(client_shell->impl()->universal);
   }
 }
 
-gearman_return_t gearman_client_wait(gearman_client_st *client)
+gearman_return_t gearman_client_wait(gearman_client_st *client_shell)
 {
-  if (client)
+  if (client_shell)
   {
-    return gearman_wait(client->universal);
+    return gearman_wait(client_shell->impl()->universal);
   }
 
   return GEARMAN_INVALID_ARGUMENT;
 }
 
-void *gearman_client_do(gearman_client_st *client,
+void *gearman_client_do(gearman_client_st *client_shell,
                         const char *function,
                         const char *unique,
                         const void *workload,
                         size_t workload_size, size_t *result_size,
                         gearman_return_t *ret_ptr)
 {
-  return _client_do(client, GEARMAN_COMMAND_SUBMIT_JOB,
+  return _client_do(client_shell, GEARMAN_COMMAND_SUBMIT_JOB,
                     function,
                     unique,
                     workload, workload_size,
                     result_size, ret_ptr);
 }
 
-void *gearman_client_do_high(gearman_client_st *client,
+void *gearman_client_do_high(gearman_client_st *client_shell,
                              const char *function,
                              const char *unique,
                              const void *workload, size_t workload_size,
                              size_t *result_size, gearman_return_t *ret_ptr)
 {
-  return _client_do(client, GEARMAN_COMMAND_SUBMIT_JOB_HIGH,
+  return _client_do(client_shell, GEARMAN_COMMAND_SUBMIT_JOB_HIGH,
                     function,
                     unique,
                     workload, workload_size,
                     result_size, ret_ptr);
 }
 
-void *gearman_client_do_low(gearman_client_st *client,
+void *gearman_client_do_low(gearman_client_st *client_shell,
                             const char *function,
                             const char *unique,
                             const void *workload, size_t workload_size,
                             size_t *result_size, gearman_return_t *ret_ptr)
 {
-  return _client_do(client, GEARMAN_COMMAND_SUBMIT_JOB_LOW,
+  return _client_do(client_shell, GEARMAN_COMMAND_SUBMIT_JOB_LOW,
                     function,
                     unique,
                     workload, workload_size,
                     result_size, ret_ptr);
 }
 
-size_t gearman_client_count_tasks(gearman_client_st *client)
+size_t gearman_client_count_tasks(gearman_client_st *client_shell)
 {
-  if (client == NULL)
+  if (client_shell == NULL)
   {
     return 0;
   }
 
   size_t count= 1;
-  gearman_task_st *search= client->task_list;
+  gearman_task_st *search= client_shell->impl()->task_list;
 
-  while ((search= search->next))
+  while ((search= search->impl()->next))
   {
     count++;
   }
@@ -643,10 +662,10 @@
 }
 
 #if 0
-static bool _active_tasks(gearman_client_st *client)
+static bool _active_tasks(gearman_client_st *client_shell)
 {
-  assert(client);
-  gearman_task_st *search= client->task_list;
+  assert(client_shell);
+  gearman_task_st *search= client_shell->impl()->task_list;
 
   if (not search)
     return false;
@@ -667,7 +686,7 @@
 {
   if (self)
   {
-    return self->_do_handle;
+    return self->impl()->_do_handle;
   }
 
   errno= EINVAL;
@@ -687,7 +706,7 @@
   }
 }
 
-gearman_return_t gearman_client_do_background(gearman_client_st *client,
+gearman_return_t gearman_client_do_background(gearman_client_st *client_shell,
                                               const char *function_name,
                                               const char *unique,
                                               const void *workload_str,
@@ -698,14 +717,14 @@
   gearman_unique_t local_unique= gearman_unique_make(unique, unique ? strlen(unique) : 0);
   gearman_string_t workload= { static_cast<const char*>(workload_str), workload_size };
 
-  return _client_do_background(client, GEARMAN_COMMAND_SUBMIT_JOB_BG,
+  return _client_do_background(client_shell, GEARMAN_COMMAND_SUBMIT_JOB_BG,
                                function,
                                local_unique,
                                workload,
                                job_handle);
 }
 
-gearman_return_t gearman_client_do_high_background(gearman_client_st *client,
+gearman_return_t gearman_client_do_high_background(gearman_client_st *client_shell,
                                                    const char *function_name,
                                                    const char *unique,
                                                    const void *workload_str,
@@ -716,14 +735,14 @@
   gearman_unique_t local_unique= gearman_unique_make(unique, unique ? strlen(unique) : 0);
   gearman_string_t workload= { static_cast<const char*>(workload_str), workload_size };
 
-  return _client_do_background(client, GEARMAN_COMMAND_SUBMIT_JOB_HIGH_BG,
+  return _client_do_background(client_shell, GEARMAN_COMMAND_SUBMIT_JOB_HIGH_BG,
                                function,
                                local_unique,
                                workload,
                                job_handle);
 }
 
-gearman_return_t gearman_client_do_low_background(gearman_client_st *client,
+gearman_return_t gearman_client_do_low_background(gearman_client_st *client_shell,
                                                   const char *function_name,
                                                   const char *unique,
                                                   const void *workload_str,
@@ -734,7 +753,7 @@
   gearman_unique_t local_unique= gearman_unique_make(unique, unique ? strlen(unique) : 0);
   gearman_string_t workload= { static_cast<const char*>(workload_str), workload_size };
 
-  return _client_do_background(client, GEARMAN_COMMAND_SUBMIT_JOB_LOW_BG,
+  return _client_do_background(client_shell, GEARMAN_COMMAND_SUBMIT_JOB_LOW_BG,
                                function,
                                local_unique,
                                workload,
@@ -754,22 +773,28 @@
     return status;
   }
 
-  universal_reset_error(client->universal);
+  client->impl()->universal.reset_error();
 
   gearman_return_t ret;
   gearman_task_st do_task;
-  gearman_task_st *do_task_ptr= gearman_client_add_task_status_by_unique(client,
-                                                                         &do_task,
-                                                                         unique, &ret);
-  if (gearman_failed(ret))
   {
-    gearman_status_set_return(status, ret);
-    return status;
+    gearman_task_st *do_task_ptr= gearman_client_add_task_status_by_unique(client,
+                                                                           &do_task,
+                                                                           unique, &ret);
+    if (gearman_failed(ret))
+    {
+      gearman_status_set_return(status, ret);
+      return status;
+    }
+    (void)do_task_ptr;
+    assert(do_task_ptr);
+    assert(&do_task == do_task_ptr);
   }
-  assert(do_task_ptr);
-  do_task_ptr->type= GEARMAN_TASK_KIND_DO;
-
-  gearman_task_clear_fn(do_task_ptr);
+
+  Task* task= do_task.impl();
+  task->type= GEARMAN_TASK_KIND_DO;
+
+  gearman_task_clear_fn(&do_task);
 
   ret= gearman_client_run_block_tasks(client);
 
@@ -779,26 +804,26 @@
   if (gearman_success(ret))
   {
     gearman_status_set(status,
-                       do_task.options.is_known,
-                       do_task.options.is_running,
-                       do_task.numerator,
-                       do_task.denominator,
-                       do_task.client_count);
+                       task->options.is_known,
+                       task->options.is_running,
+                       task->numerator,
+                       task->denominator,
+                       task->client_count);
 
     if (gearman_status_is_known(status) == false and gearman_status_is_running(status) == false)
     {
-      if (do_task.options.is_running) 
+      if (task->options.is_running) 
       {
         ret= GEARMAN_IN_PROGRESS;
       }
-      else if (do_task.options.is_known)
+      else if (task->options.is_known)
       {
         ret= GEARMAN_JOB_EXISTS;
       }
     }
   }
 
-  gearman_task_free(do_task_ptr);
+  gearman_task_free(&do_task);
 
   gearman_status_set_return(status, ret);
 
@@ -818,19 +843,21 @@
     return GEARMAN_INVALID_ARGUMENT;
   }
 
-  universal_reset_error(client->universal);
+  client->impl()->universal.reset_error();
 
   gearman_task_st do_task;
-  gearman_task_st *do_task_ptr= gearman_client_add_task_status(client, &do_task, client,
-                                                               job_handle, &ret);
-  if (gearman_failed(ret))
   {
-    return ret;
+    gearman_task_st *do_task_ptr= gearman_client_add_task_status(client, &do_task, client,
+                                                                 job_handle, &ret);
+    if (gearman_failed(ret))
+    {
+      return ret;
+    }
+    assert_msg(do_task_ptr, "Programming error, a NULL return happend from gearman_client_add_task_status() without an error");
   }
-  assert(do_task_ptr);
-  do_task_ptr->type= GEARMAN_TASK_KIND_DO;
+  do_task.impl()->type= GEARMAN_TASK_KIND_DO;
 
-  gearman_task_clear_fn(do_task_ptr);
+  gearman_task_clear_fn(&do_task);
 
   ret= gearman_client_run_block_tasks(client);
 
@@ -841,31 +868,31 @@
   {
     if (is_known)
     {
-      *is_known= do_task.options.is_known;
+      *is_known= do_task.impl()->options.is_known;
     }
 
     if (is_running)
     {
-      *is_running= do_task.options.is_running;
+      *is_running= do_task.impl()->options.is_running;
     }
 
     if (numerator)
     {
-      *numerator= do_task.numerator;
+      *numerator= do_task.impl()->numerator;
     }
 
     if (denominator)
     {
-      *denominator= do_task.denominator;
+      *denominator= do_task.impl()->denominator;
     }
 
     if (is_known == false and is_running == false)
     {
-      if (do_task.options.is_running) 
+      if (do_task.impl()->options.is_running) 
       {
         ret= GEARMAN_IN_PROGRESS;
       }
-      else if (do_task.options.is_known)
+      else if (do_task.impl()->options.is_known)
       {
         ret= GEARMAN_JOB_EXISTS;
       }
@@ -893,7 +920,7 @@
       *denominator= 0;
     }
   }
-  gearman_task_free(do_task_ptr);
+  gearman_task_free(&do_task);
 
   return ret;
 }
@@ -907,16 +934,16 @@
     return GEARMAN_INVALID_ARGUMENT;
   }
 
-  return gearman_echo(client->universal, workload, workload_size);
+  return gearman_echo(client->impl()->universal, workload, workload_size);
 }
 
 void gearman_client_task_free_all(gearman_client_st *client)
 {
-  if (client and client->task_list)
+  if (client and client->impl()->task_list)
   {
-    while (client->task_list)
+    while (client->impl()->task_list)
     {
-      gearman_task_free(client->task_list);
+      gearman_task_free(client->impl()->task_list);
     }
   }
 }
@@ -927,7 +954,7 @@
 {
   if (client)
   {
-    client->task_context_free_fn= function;
+    client->impl()->task_context_free_fn= function;
   }
 }
 
@@ -943,7 +970,7 @@
     return GEARMAN_INVALID_ARGUMENT;
   }
 
-  return gearman_set_memory_allocator(client->universal.allocator, malloc_fn, free_fn, realloc_fn, calloc_fn, context);
+  return gearman_set_memory_allocator(client->impl()->universal.allocator, malloc_fn, free_fn, realloc_fn, calloc_fn, context);
 }
 
 
@@ -975,7 +1002,7 @@
                       workload, workload_size,
                       time_t(0),
                       ret_ptr,
-                      client->actions);
+                      client->impl()->actions);
 }
 
 gearman_task_st *gearman_client_add_task_high(gearman_client_st *client,
@@ -1005,7 +1032,7 @@
                       workload, workload_size,
                       time_t(0),
                       ret_ptr,
-                      client->actions);
+                      client->impl()->actions);
 }
 
 gearman_task_st *gearman_client_add_task_low(gearman_client_st *client,
@@ -1034,7 +1061,7 @@
                       workload, workload_size,
                       time_t(0),
                       ret_ptr,
-                      client->actions);
+                      client->impl()->actions);
 }
 
 gearman_task_st *gearman_client_add_task_background(gearman_client_st *client,
@@ -1063,7 +1090,7 @@
                       workload, workload_size,
                       time_t(0),
                       ret_ptr,
-                      client->actions);
+                      client->impl()->actions);
 }
 
 gearman_task_st *
@@ -1094,7 +1121,7 @@
                       workload, workload_size,
                       time_t(0),
                       ret_ptr,
-                      client->actions);
+                      client->impl()->actions);
 }
 
 gearman_task_st* gearman_client_add_task_low_background(gearman_client_st *client,
@@ -1124,12 +1151,12 @@
                       workload, workload_size,
                       time_t(0),
                       ret_ptr,
-                      client->actions);
+                      client->impl()->actions);
 
 }
 
 gearman_task_st *gearman_client_add_task_status(gearman_client_st *client,
-                                                gearman_task_st *task,
+                                                gearman_task_st *task_shell,
                                                 void *context,
                                                 const gearman_job_handle_t job_handle,
                                                 gearman_return_t *ret_ptr)
@@ -1149,34 +1176,36 @@
     return NULL;
   }
 
-  if ((task= gearman_task_internal_create(client, task)) == NULL)
+  if ((task_shell= gearman_task_internal_create(*client, task_shell)) == NULL)
   {
     *ret_ptr= GEARMAN_MEMORY_ALLOCATION_FAILURE;
     return NULL;
   }
 
+  Task* task= task_shell->impl();
+
   task->context= context;
   snprintf(task->job_handle, GEARMAN_JOB_HANDLE_SIZE, "%s", job_handle);
 
   args[0]= job_handle;
   args_size[0]= strlen(job_handle);
-  gearman_return_t rc= gearman_packet_create_args(client->universal, task->send,
+  gearman_return_t rc= gearman_packet_create_args(client->impl()->universal, task->send,
                                                   GEARMAN_MAGIC_REQUEST,
                                                   GEARMAN_COMMAND_GET_STATUS,
                                                   args, args_size, 1);
   if (gearman_success(rc))
   {
-    client->new_tasks++;
-    client->running_tasks++;
+    client->impl()->new_tasks++;
+    client->impl()->running_tasks++;
     task->options.send_in_use= true;
   }
   *ret_ptr= rc;
 
-  return task;
+  return task_shell;
 }
 
 gearman_task_st *gearman_client_add_task_status_by_unique(gearman_client_st *client,
-                                                          gearman_task_st *task_ptr,
+                                                          gearman_task_st *task_shell,
                                                           const char *unique_handle,
                                                           gearman_return_t *ret_ptr)
 {
@@ -1208,32 +1237,33 @@
     return NULL;
   }
 
-  gearman_task_st *task;
-  if ((task= gearman_task_internal_create(client, task_ptr)) == NULL)
+  if ((task_shell= gearman_task_internal_create(*client, task_shell)) == NULL)
   {
     *ret_ptr= GEARMAN_MEMORY_ALLOCATION_FAILURE;
     return NULL;
   }
 
+  Task* task= task_shell->impl();
+
   task->unique_length= unique_length;
   memcpy(task->unique, unique_handle, unique_length);
   task->unique[task->unique_length]= 0;
 
   args[0]= task->unique;
   args_size[0]= task->unique_length;
-  gearman_return_t rc= gearman_packet_create_args(client->universal, task->send,
+  gearman_return_t rc= gearman_packet_create_args(client->impl()->universal, task->send,
                                                   GEARMAN_MAGIC_REQUEST,
                                                   GEARMAN_COMMAND_GET_STATUS_UNIQUE,
                                                   args, args_size, 1);
   if (gearman_success(rc))
   {
-    client->new_tasks++;
-    client->running_tasks++;
+    client->impl()->new_tasks++;
+    client->impl()->running_tasks++;
     task->options.send_in_use= true;
   }
   *ret_ptr= rc;
 
-  return task;
+  return task_shell;
 }
 
 void gearman_client_set_workload_fn(gearman_client_st *client,
@@ -1241,7 +1271,7 @@
 {
   if (client)
   {
-    client->actions.workload_fn= function;
+    client->impl()->actions.workload_fn= function;
   }
 }
 
@@ -1250,7 +1280,7 @@
 {
   if (client)
   {
-    client->actions.created_fn= function;
+    client->impl()->actions.created_fn= function;
   }
 }
 
@@ -1259,7 +1289,7 @@
 {
   if (client)
   {
-    client->actions.data_fn= function;
+    client->impl()->actions.data_fn= function;
   }
 }
 
@@ -1268,7 +1298,7 @@
 {
   if (client)
   {
-    client->actions.warning_fn= function;
+    client->impl()->actions.warning_fn= function;
   }
 }
 
@@ -1277,7 +1307,7 @@
 {
   if (client)
   {
-    client->actions.status_fn= function;
+    client->impl()->actions.status_fn= function;
   }
 }
 
@@ -1286,7 +1316,7 @@
 {
   if (client)
   {
-    client->actions.complete_fn= function;
+    client->impl()->actions.complete_fn= function;
   }
 }
 
@@ -1295,24 +1325,24 @@
 {
   if (client)
   {
-    client->actions.exception_fn= function;
+    client->impl()->actions.exception_fn= function;
   }
 }
 
-void gearman_client_set_fail_fn(gearman_client_st *client,
+void gearman_client_set_fail_fn(gearman_client_st* client,
                                 gearman_fail_fn *function)
 {
   if (client)
   {
-    client->actions.fail_fn= function;
+    client->impl()->actions.fail_fn= function;
   }
 }
 
-void gearman_client_clear_fn(gearman_client_st *client)
+void gearman_client_clear_fn(gearman_client_st* client)
 {
   if (client)
   {
-    client->actions= gearman_actions_default();
+    client->impl()->actions= gearman_actions_default();
   }
 }
 
@@ -1320,42 +1350,42 @@
 {
   gearman_return_t ret= GEARMAN_MAX_RETURN;
 
-  switch(client->state)
+  switch(client->impl()->state)
   {
   case GEARMAN_CLIENT_STATE_IDLE:
     while (1)
     {
       /* Start any new tasks. */
-      if (client->new_tasks > 0 && ! (client->options.no_new))
+      if (client->impl()->new_tasks > 0 && ! (client->impl()->options.no_new))
       {
-        for (client->task= client->task_list; client->task;
-             client->task= client->task->next)
+        for (client->impl()->task= client->impl()->task_list; client->impl()->task;
+             client->impl()->task= client->impl()->task->impl()->next)
         {
-          if (client->task->state != GEARMAN_TASK_STATE_NEW)
+          if (client->impl()->task->impl()->state != GEARMAN_TASK_STATE_NEW)
           {
             continue;
           }
 
   case GEARMAN_CLIENT_STATE_NEW:
-          if (client->task == NULL)
+          if (client->impl()->task == NULL)
           {
-            client->state= GEARMAN_CLIENT_STATE_IDLE;
+            client->impl()->state= GEARMAN_CLIENT_STATE_IDLE;
             break;
           }
 
-          assert_msg(client == client->task->client, "Programmer error, client and task member client are not the same");
-          gearman_return_t local_ret= _client_run_task(client->task);
+          assert_msg(client == client->impl()->task->impl()->client, "Programmer error, client and task member client are not the same");
+          gearman_return_t local_ret= _client_run_task(client->impl()->task->impl());
           if (gearman_failed(local_ret) and local_ret != GEARMAN_IO_WAIT)
           {
-            client->state= GEARMAN_CLIENT_STATE_NEW;
+            client->impl()->state= GEARMAN_CLIENT_STATE_NEW;
 
             return local_ret;
           }
         }
 
-        if (client->new_tasks == 0)
+        if (client->impl()->new_tasks == 0)
         {
-          gearman_return_t local_ret= gearman_flush_all(client->universal);
+          gearman_return_t local_ret= gearman_flush_all(client->impl()->universal);
           if (gearman_failed(local_ret))
           {
             return local_ret;
@@ -1364,52 +1394,52 @@
       }
 
       /* See if there are any connections ready for I/O. */
-      while ((client->con= gearman_ready(client->universal)))
+      while ((client->impl()->con= gearman_ready(client->impl()->universal)))
       {
-        if (client->con->revents & (POLLOUT | POLLERR | POLLHUP | POLLNVAL))
+        if (client->impl()->con->revents & (POLLOUT | POLLERR | POLLHUP | POLLNVAL))
         {
           /* Socket is ready for writing, continue submitting jobs. */
-          for (client->task= client->task_list; client->task;
-               client->task= client->task->next)
+          for (client->impl()->task= client->impl()->task_list; client->impl()->task;
+               client->impl()->task= client->impl()->task->impl()->next)
           {
-            if (client->task->con != client->con or
-                (client->task->state != GEARMAN_TASK_STATE_SUBMIT and
-                 client->task->state != GEARMAN_TASK_STATE_WORKLOAD))
+            if (client->impl()->task->impl()->con != client->impl()->con or
+                (client->impl()->task->impl()->state != GEARMAN_TASK_STATE_SUBMIT and
+                 client->impl()->task->impl()->state != GEARMAN_TASK_STATE_WORKLOAD))
             {
               continue;
             }
 
   case GEARMAN_CLIENT_STATE_SUBMIT:
-            if (client->task == NULL)
+            if (client->impl()->task == NULL)
             {
-              client->state= GEARMAN_CLIENT_STATE_IDLE;
+              client->impl()->state= GEARMAN_CLIENT_STATE_IDLE;
               break;
             }
-            assert_msg(client == client->task->client, "Programmer error, client and task member client are not the same");
-            gearman_return_t local_ret= _client_run_task(client->task);
+            assert_msg(client == client->impl()->task->impl()->client, "Programmer error, client and task member client are not the same");
+            gearman_return_t local_ret= _client_run_task(client->impl()->task->impl());
             if (local_ret == GEARMAN_COULD_NOT_CONNECT)
             {
-              client->state= GEARMAN_CLIENT_STATE_IDLE;
+              client->impl()->state= GEARMAN_CLIENT_STATE_IDLE;
               return local_ret;
             }
             else if (gearman_failed(local_ret) and local_ret != GEARMAN_IO_WAIT)
             {
-              client->state= GEARMAN_CLIENT_STATE_SUBMIT;
+              client->impl()->state= GEARMAN_CLIENT_STATE_SUBMIT;
               return local_ret;
             }
           }
 
           /* Connection errors are fatal. */
-          if (client->con->revents & (POLLERR | POLLHUP | POLLNVAL))
+          if (client->impl()->con->revents & (POLLERR | POLLHUP | POLLNVAL))
           {
-            gearman_error(client->universal, GEARMAN_LOST_CONNECTION, "detected lost connection in _client_run_tasks()");
-            client->con->close_socket();
-            client->state= GEARMAN_CLIENT_STATE_IDLE;
+            gearman_error(client->impl()->universal, GEARMAN_LOST_CONNECTION, "detected lost connection in _client_run_tasks()");
+            client->impl()->con->close_socket();
+            client->impl()->state= GEARMAN_CLIENT_STATE_IDLE;
             return GEARMAN_LOST_CONNECTION;
           }
         }
 
-        if ((client->con->revents & POLLIN) == 0)
+        if ((client->impl()->con->revents & POLLIN) == 0)
         {
           continue;
         }
@@ -1418,17 +1448,17 @@
         while (1)
         {
           /* Read packet on connection and find which task it belongs to. */
-          if (client->options.unbuffered_result)
+          if (client->impl()->options.unbuffered_result)
           {
             /* If client is handling the data read, make sure it's complete. */
-            if (client->con->recv_state == GEARMAN_CON_RECV_STATE_READ_DATA)
+            if (client->impl()->con->recv_state == GEARMAN_CON_RECV_STATE_READ_DATA)
             {
-              for (client->task= client->task_list; client->task;
-                   client->task= client->task->next)
+              for (client->impl()->task= client->impl()->task_list; client->impl()->task;
+                   client->impl()->task= client->impl()->task->impl()->next)
               {
-                if (client->task->con == client->con &&
-                    (client->task->state == GEARMAN_TASK_STATE_DATA or
-                     client->task->state == GEARMAN_TASK_STATE_COMPLETE))
+                if (client->impl()->task->impl()->con == client->impl()->con &&
+                    (client->impl()->task->impl()->state == GEARMAN_TASK_STATE_DATA or
+                     client->impl()->task->impl()->state == GEARMAN_TASK_STATE_COMPLETE))
                 {
                   break;
                 }
@@ -1438,24 +1468,24 @@
                 Someone has set GEARMAN_CLIENT_UNBUFFERED_RESULT but hasn't setup the client to fetch data correctly.
                 Fatal error :(
               */
-              return gearman_universal_set_error(client->universal, GEARMAN_INVALID_ARGUMENT, GEARMAN_AT,
+              return gearman_universal_set_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, GEARMAN_AT,
                                                  "client created with GEARMAN_CLIENT_UNBUFFERED_RESULT, but was not setup to use it. %s", __func__);
             }
             else
             {
               /* Read the next packet, without buffering the data part. */
-              client->task= NULL;
-              (void)client->con->receiving(client->con->_packet, ret, false);
+              client->impl()->task= NULL;
+              (void)client->impl()->con->receiving(client->impl()->con->_packet, ret, false);
             }
           }
           else
           {
             /* Read the next packet, buffering the data part. */
-            client->task= NULL;
-            (void)client->con->receiving(client->con->_packet, ret, true);
+            client->impl()->task= NULL;
+            (void)client->impl()->con->receiving(client->impl()->con->_packet, ret, true);
           }
 
-          if (client->task == NULL)
+          if (client->impl()->task == NULL)
           {
             assert(ret != GEARMAN_MAX_RETURN);
 
@@ -1467,65 +1497,65 @@
                 break;
               }
 
-              client->state= GEARMAN_CLIENT_STATE_IDLE;
+              client->impl()->state= GEARMAN_CLIENT_STATE_IDLE;
               return ret;
             }
 
-            client->con->options.packet_in_use= true;
+            client->impl()->con->options.packet_in_use= true;
 
             /* We have a packet, see which task it belongs to. */
-            for (client->task= client->task_list; client->task;
-                 client->task= client->task->next)
+            for (client->impl()->task= client->impl()->task_list; client->impl()->task;
+                 client->impl()->task= client->impl()->task->impl()->next)
             {
-              if (client->task->con != client->con)
+              if (client->impl()->task->impl()->con != client->impl()->con)
               {
                 continue;
               }
 
-              gearman_log_debug(&client->universal, "Got %s", gearman_strcommand(client->con->_packet.command));
-              if (client->con->_packet.command == GEARMAN_COMMAND_JOB_CREATED)
+              gearman_log_debug(&client->impl()->universal, "Got %s", gearman_strcommand(client->impl()->con->_packet.command));
+              if (client->impl()->con->_packet.command == GEARMAN_COMMAND_JOB_CREATED)
               {
-                if (client->task->created_id != client->con->created_id)
+                if (client->impl()->task->impl()->created_id != client->impl()->con->created_id)
                 {
                   continue;
                 }
 
                 /* New job created, drop through below and notify task. */
-                client->con->created_id++;
+                client->impl()->con->created_id++;
               }
-              else if (client->con->_packet.command == GEARMAN_COMMAND_ERROR)
+              else if (client->impl()->con->_packet.command == GEARMAN_COMMAND_ERROR)
               {
-                gearman_universal_set_error(client->universal, GEARMAN_SERVER_ERROR, GEARMAN_AT,
+                gearman_universal_set_error(client->impl()->universal, GEARMAN_SERVER_ERROR, GEARMAN_AT,
                                             "%s:%.*s",
-                                            static_cast<char *>(client->con->_packet.arg[0]),
-                                            int(client->con->_packet.arg_size[1]),
-                                            static_cast<char *>(client->con->_packet.arg[1]));
+                                            static_cast<char *>(client->impl()->con->_packet.arg[0]),
+                                            int(client->impl()->con->_packet.arg_size[1]),
+                                            static_cast<char *>(client->impl()->con->_packet.arg[1]));
 
                 /* 
                   Packet cleanup copied from "Clean up the packet" below, and must
                   remain in sync with its reference.
                 */
-                gearman_packet_free(&(client->con->_packet));
-                client->con->options.packet_in_use= false;
+                gearman_packet_free(&(client->impl()->con->_packet));
+                client->impl()->con->options.packet_in_use= false;
 
                 /* This step copied from _client_run_tasks() above: */
                 /* Increment this value because new job created then failed. */
-                client->con->created_id++;
+                client->impl()->con->created_id++;
 
                 return GEARMAN_SERVER_ERROR;
               }
-              else if (client->con->_packet.command == GEARMAN_COMMAND_STATUS_RES_UNIQUE and
-                       (strncmp(gearman_task_unique(client->task),
-                               static_cast<char *>(client->con->_packet.arg[0]),
-                               client->con->_packet.arg_size[0]) == 0))
+              else if (client->impl()->con->_packet.command == GEARMAN_COMMAND_STATUS_RES_UNIQUE and
+                       (strncmp(gearman_task_unique(client->impl()->task),
+                               static_cast<char *>(client->impl()->con->_packet.arg[0]),
+                               client->impl()->con->_packet.arg_size[0]) == 0))
               { }
-              else if (strncmp(client->task->job_handle,
-                               static_cast<char *>(client->con->_packet.arg[0]),
-                               client->con->_packet.arg_size[0]) ||
-                       (client->con->_packet.command != GEARMAN_COMMAND_WORK_FAIL &&
-                        strlen(client->task->job_handle) != client->con->_packet.arg_size[0] - 1) ||
-                       (client->con->_packet.command == GEARMAN_COMMAND_WORK_FAIL &&
-                        strlen(client->task->job_handle) != client->con->_packet.arg_size[0]))
+              else if (strncmp(client->impl()->task->impl()->job_handle,
+                               static_cast<char *>(client->impl()->con->_packet.arg[0]),
+                               client->impl()->con->_packet.arg_size[0]) ||
+                       (client->impl()->con->_packet.command != GEARMAN_COMMAND_WORK_FAIL &&
+                        strlen(client->impl()->task->impl()->job_handle) != client->impl()->con->_packet.arg_size[0] - 1) ||
+                       (client->impl()->con->_packet.command == GEARMAN_COMMAND_WORK_FAIL &&
+                        strlen(client->impl()->task->impl()->job_handle) != client->impl()->con->_packet.arg_size[0]))
               {
                 continue;
               }
@@ -1535,20 +1565,20 @@
               break;
             }
 
-            if (client->task == NULL)
+            if (client->impl()->task == NULL)
             {
               /* The client has stopped waiting for the response, ignore it. */
-              client->con->free_private_packet();
+              client->impl()->con->free_private_packet();
               continue;
             }
 
-            client->task->recv= &(client->con->_packet);
+            client->impl()->task->impl()->recv= &(client->impl()->con->_packet);
           }
 
   case GEARMAN_CLIENT_STATE_PACKET:
           /* Let task process job created or result packet. */
-          assert_msg(client == client->task->client, "Programmer error, client and task member client are not the same");
-          gearman_return_t local_ret= _client_run_task(client->task);
+          assert_msg(client == client->impl()->task->impl()->client, "Programmer error, client and task member client are not the same");
+          gearman_return_t local_ret= _client_run_task(client->impl()->task->impl());
           if (local_ret == GEARMAN_IO_WAIT)
           {
             break;
@@ -1556,46 +1586,46 @@
 
           if (gearman_failed(local_ret))
           {
-            client->state= GEARMAN_CLIENT_STATE_PACKET;
+            client->impl()->state= GEARMAN_CLIENT_STATE_PACKET;
             return local_ret;
           }
 
           /* Clean up the packet. */
-          client->con->free_private_packet();
+          client->impl()->con->free_private_packet();
 
           /* If all tasks are done, return. */
-          if (client->running_tasks == 0)
+          if (client->impl()->running_tasks == 0)
           {
-            client->state= GEARMAN_CLIENT_STATE_IDLE;
+            client->impl()->state= GEARMAN_CLIENT_STATE_IDLE;
             return GEARMAN_SUCCESS;
           }
         }
       }
 
       /* If all tasks are done, return. */
-      if (client->running_tasks == 0)
+      if (client->impl()->running_tasks == 0)
       {
         break;
       }
 
-      if (client->new_tasks > 0 and ! (client->options.no_new))
+      if (client->impl()->new_tasks > 0 and ! (client->impl()->options.no_new))
       {
         continue;
       }
 
-      if (client->options.non_blocking)
+      if (client->impl()->options.non_blocking)
       {
         /* Let the caller wait for activity. */
-        client->state= GEARMAN_CLIENT_STATE_IDLE;
+        client->impl()->state= GEARMAN_CLIENT_STATE_IDLE;
 
-        return gearman_gerror(client->universal, GEARMAN_IO_WAIT);
+        return gearman_gerror(client->impl()->universal, GEARMAN_IO_WAIT);
       }
 
       /* Wait for activity on one of the connections. */
-      gearman_return_t local_ret= gearman_wait(client->universal);
+      gearman_return_t local_ret= gearman_wait(client->impl()->universal);
       if (gearman_failed(local_ret) and local_ret != GEARMAN_IO_WAIT)
       {
-        client->state= GEARMAN_CLIENT_STATE_IDLE;
+        client->impl()->state= GEARMAN_CLIENT_STATE_IDLE;
 
         return local_ret;
       }
@@ -1604,7 +1634,7 @@
     break;
   }
 
-  client->state= GEARMAN_CLIENT_STATE_IDLE;
+  client->impl()->state= GEARMAN_CLIENT_STATE_IDLE;
 
   return GEARMAN_SUCCESS;
 }
@@ -1616,7 +1646,7 @@
     return GEARMAN_INVALID_ARGUMENT;
   }
 
-  if (client->task_list == NULL) // We are immediatly successful if all tasks are completed
+  if (client->impl()->task_list == NULL) // We are immediatly successful if all tasks are completed
   {
     return GEARMAN_SUCCESS;
   }
@@ -1630,7 +1660,7 @@
 
   if (rc == GEARMAN_COULD_NOT_CONNECT)
   {
-    gearman_reset(client->universal);
+    gearman_reset(client->impl()->universal);
   }
 
   return rc;
@@ -1643,7 +1673,7 @@
     return GEARMAN_INVALID_ARGUMENT;
   }
 
-  if (client->task_list == NULL) // We are immediatly successful if all tasks are completed
+  if (client->impl()->task_list == NULL) // We are immediatly successful if all tasks are completed
   {
     return GEARMAN_SUCCESS;
   }
@@ -1660,12 +1690,12 @@
   {
     if (rc == GEARMAN_COULD_NOT_CONNECT)
     {
-      gearman_reset(client->universal);
+      gearman_reset(client->impl()->universal);
     }
 
-    if (gearman_universal_error_code(client->universal) != rc and rc != GEARMAN_COULD_NOT_CONNECT)
+    if (client->impl()->universal.error_code() != rc and rc != GEARMAN_COULD_NOT_CONNECT)
     {
-      assert(gearman_universal_error_code(client->universal) == rc);
+      assert(client->impl()->universal.error_code() == rc);
     }
   }
 
@@ -1678,22 +1708,20 @@
 
 bool gearman_client_compare(const gearman_client_st *first, const gearman_client_st *second)
 {
-  if (first == NULL or second == NULL)
-  {
-    return false;
-  }
-
-  if (strcmp(first->universal.con_list->host, second->universal.con_list->host))
-  {
-    return false;
-  }
-
-  if (first->universal.con_list->port != second->universal.con_list->port)
-  {
-    return false;
-  }
-
-  return true;
+  if (first and second)
+  {
+    if (strcmp(first->impl()->universal.con_list->_host, second->impl()->universal.con_list->_host) == 0)
+    {
+      if (strcmp(first->impl()->universal.con_list->_service, second->impl()->universal.con_list->_service) == 0)
+      {
+        return true;
+      }
+      fprintf(stderr, "Compared %s != %s\n", first->impl()->universal.con_list->_service, second->impl()->universal.con_list->_service);
+    }
+    fprintf(stderr, "Compared %s != %s\n", first->impl()->universal.con_list->_host, second->impl()->universal.con_list->_host);
+  }
+
+  return false;
 }
 
 bool gearman_client_set_server_option(gearman_client_st *self, const char *option_arg, size_t option_arg_size)
@@ -1701,7 +1729,7 @@
   if (self)
   {
     gearman_string_t option= { option_arg, option_arg_size };
-    return gearman_request_option(self->universal, option);
+    return gearman_request_option(self->impl()->universal, option);
   }
 
   return false;
@@ -1711,17 +1739,27 @@
 {
   if (self)
   {
-    gearman_universal_set_namespace(self->universal, namespace_key, namespace_key_size);
+    gearman_universal_set_namespace(self->impl()->universal, namespace_key, namespace_key_size);
   }
 }
 
 gearman_return_t gearman_client_set_identifier(gearman_client_st *client,
                                                const char *id, size_t id_size)
 {
-  return gearman_set_identifier(client->universal, id, id_size);
+  return gearman_set_identifier(client->impl()->universal, id, id_size);
 }
 
 const char *gearman_client_namespace(gearman_client_st *self)
 {
-  return gearman_univeral_namespace(self->universal);
+  return gearman_univeral_namespace(self->impl()->universal);
+}
+
+bool gearman_client_has_tasks(const gearman_client_st *client_shell)
+{
+  if (client_shell and client_shell->impl())
+  {
+    return bool(client_shell->impl()->task_list);
+  }
+
+  return false;
 }

=== modified file 'libgearman/common.h'
--- libgearman/common.h	2012-08-02 05:44:19 +0000
+++ libgearman/common.h	2012-09-20 02:21:22 +0000
@@ -39,7 +39,13 @@
 
 #pragma once
 
+struct Client;
+struct Task;
+struct Worker;
+struct gearman_client_st;
+struct gearman_connection_st;
 struct gearman_result_st;
+struct gearman_universal_st;
 
 #include <libgearman-1.0/gearman.h>
 
@@ -65,7 +71,11 @@
 #include <libgearman/command.h>
 #include <libgearman/task.hpp>
 #include <libgearman/job.h>
+#include <libgearman/job.hpp>
 
 #include <libgearman/status.hpp>
 
 #include <libgearman/protocol/submit.h>
+#include <libgearman/interface/client.hpp>
+#include <libgearman/interface/task.hpp>
+#include <libgearman/interface/worker.hpp>

=== modified file 'libgearman/connection.cc'
--- libgearman/connection.cc	2012-09-16 00:30:28 +0000
+++ libgearman/connection.cc	2012-09-20 02:21:22 +0000
@@ -170,7 +170,6 @@
   state(GEARMAN_CON_UNIVERSAL_ADDRINFO),
   send_state(GEARMAN_CON_SEND_STATE_NONE),
   recv_state(GEARMAN_CON_RECV_UNIVERSAL_NONE),
-  port(0),
   events(0),
   revents(0),
   fd(-1),
@@ -214,7 +213,8 @@
 
   send_buffer_ptr= send_buffer;
   recv_buffer_ptr= recv_buffer;
-  host[0]= 0;
+  _host[0]= 0;
+  _service[0]= 0;
 }
 
 gearman_connection_st *gearman_connection_create(gearman_universal_st &universal,
@@ -231,9 +231,30 @@
 }
 
 gearman_connection_st *gearman_connection_create_args(gearman_universal_st& universal,
+                                                      const char *host, const char* service_)
+{
+  gearman_connection_st *connection= gearman_connection_create(universal);
+  if (connection == NULL)
+  {
+    return NULL;
+  }
+
+  connection->set_host(host, service_);
+
+  if (gearman_failed(connection->lookup()))
+  {
+    gearman_gerror(universal, GEARMAN_GETADDRINFO);
+    delete connection;
+    return NULL;
+  }
+
+  return connection;
+}
+
+gearman_connection_st *gearman_connection_create_args(gearman_universal_st& universal,
                                                       const char *host, in_port_t port)
 {
-  gearman_connection_st *connection= gearman_connection_create(universal, NULL);
+  gearman_connection_st *connection= gearman_connection_create(universal);
   if (connection == NULL)
   {
     return NULL;
@@ -254,7 +275,7 @@
 gearman_connection_st *gearman_connection_copy(gearman_universal_st& universal,
                                                const gearman_connection_st& from)
 {
-  gearman_connection_st *connection= gearman_connection_create(universal, NULL);
+  gearman_connection_st *connection= gearman_connection_create(universal);
 
   if (connection == NULL)
   {
@@ -265,8 +286,8 @@
   // @todo Is this right?
   connection->options.packet_in_use= from.options.packet_in_use;
 
-  strcpy(connection->host, from.host);
-  connection->port= from.port;
+  strcpy(connection->_host, from._host);
+  strcpy(connection->_service, from._service);
 
   return connection;
 }
@@ -355,10 +376,31 @@
 {
   reset_addrinfo();
 
-  strncpy(host, host_arg == NULL ? GEARMAN_DEFAULT_TCP_HOST : host_arg, GEARMAN_NI_MAXHOST);
-  host[GEARMAN_NI_MAXHOST - 1]= 0;
-
-  port= in_port_t(port_arg == 0 ? GEARMAN_DEFAULT_TCP_PORT : port_arg);
+  strncpy(_host, host_arg == NULL ? GEARMAN_DEFAULT_TCP_HOST : host_arg, GEARMAN_NI_MAXHOST);
+  _host[GEARMAN_NI_MAXHOST - 1]= 0;
+
+  in_port_t port= in_port_t(port_arg == 0 ? GEARMAN_DEFAULT_TCP_PORT : port_arg);
+
+  snprintf(_service, sizeof(_service), "%hu", uint16_t(port));
+  _service[GEARMAN_NI_MAXSERV - 1]= 0;
+}
+
+void gearman_connection_st::set_host(const char *host_arg, const char* service_)
+{
+  reset_addrinfo();
+
+  strncpy(_host, host_arg == NULL ? GEARMAN_DEFAULT_TCP_HOST : host_arg, GEARMAN_NI_MAXHOST);
+  _host[GEARMAN_NI_MAXHOST - 1]= 0;
+
+  if (service_)
+  {
+    strcpy(_service, service_);
+  }
+  else
+  {
+    strcpy(_service, GEARMAN_DEFAULT_TCP_PORT_STRING);
+  }
+  _service[GEARMAN_NI_MAXSERV - 1]= 0;
 }
 
 /*
@@ -576,20 +618,13 @@
 {
   reset_addrinfo();
 
-  char port_str[GEARMAN_NI_MAXSERV]= { 0 };
-  int port_str_length;
-  if (size_t(port_str_length= snprintf(port_str, sizeof(port_str), "%hu", uint16_t(port))) >= sizeof(port_str))
-  {
-    return gearman_universal_set_error(universal, GEARMAN_MEMORY_ALLOCATION_FAILURE, GEARMAN_AT, "snprintf(%d)", port_str_length);
-  }
-
   struct addrinfo ai;
   memset(&ai, 0, sizeof(struct addrinfo));
   ai.ai_socktype= SOCK_STREAM;
   ai.ai_protocol= IPPROTO_TCP;
 
   int ret;
-  if ((ret= getaddrinfo(host, port_str, &ai, &(_addrinfo))))
+  if ((ret= getaddrinfo(_host, _service, &ai, &(_addrinfo))))
   {
     reset_addrinfo();
     return gearman_universal_set_error(universal, GEARMAN_GETADDRINFO, GEARMAN_AT, "getaddrinfo:%s", gai_strerror(ret));
@@ -627,7 +662,7 @@
       if (addrinfo_next == NULL)
       {
         state= GEARMAN_CON_UNIVERSAL_ADDRINFO;
-        return gearman_universal_set_error(universal, GEARMAN_COULD_NOT_CONNECT, GEARMAN_AT, "%s:%hu", host, uint16_t(port));
+        return gearman_universal_set_error(universal, GEARMAN_COULD_NOT_CONNECT, GEARMAN_AT, "%s:%s", _host, _service);
       }
 
       // rewrite tye if HAVE_SOCK_CLOEXEC
@@ -686,7 +721,7 @@
           gearman_return_t gret= connect_poll();
           if (gearman_failed(gret))
           {
-            assert_msg(universal.error.rc != GEARMAN_SUCCESS, "Programmer error, connect_poll() returned an error, but it was not set");
+            assert_msg(universal.error_code() != GEARMAN_SUCCESS, "Programmer error, connect_poll() returned an error, but it was not set");
             close_socket();
             return gret;
           }
@@ -729,7 +764,7 @@
 
         set_events(POLLOUT);
 
-        if (gearman_universal_is_non_blocking(universal))
+        if (universal.is_non_blocking())
         {
           state= GEARMAN_CON_UNIVERSAL_CONNECTING;
           return gearman_gerror(universal, GEARMAN_IO_WAIT);
@@ -751,7 +786,7 @@
       while (send_buffer_size != 0)
       {
         ssize_t write_size= ::send(fd, send_buffer_ptr, send_buffer_size, 
-                                   gearman_universal_is_non_blocking(universal) ? MSG_NOSIGNAL| MSG_DONTWAIT : MSG_NOSIGNAL);
+                                   universal.is_non_blocking() ? MSG_NOSIGNAL| MSG_DONTWAIT : MSG_NOSIGNAL);
 
         if (write_size == 0) // Zero value on send()
         { }
@@ -761,7 +796,7 @@
           {
             set_events(POLLOUT);
 
-            if (gearman_universal_is_non_blocking(universal))
+            if (universal.is_non_blocking())
             {
               return gearman_gerror(universal, GEARMAN_IO_WAIT);
             }
@@ -1003,7 +1038,7 @@
       {
         set_events(POLLIN);
 
-        if (gearman_universal_is_non_blocking(universal))
+        if (universal.is_non_blocking())
         {
           ret= gearman_gerror(universal, GEARMAN_IO_WAIT);
           return 0;

=== modified file 'libgearman/connection.hpp'
--- libgearman/connection.hpp	2012-09-10 11:34:03 +0000
+++ libgearman/connection.hpp	2012-09-20 02:21:22 +0000
@@ -39,6 +39,8 @@
 #pragma once
 
 #include <libgearman-1.0/connection.h>
+#include "libgearman/interface/packet.hpp"
+#include "libgearman/interface/universal.hpp"
 
 struct gearman_connection_st
 {
@@ -49,7 +51,6 @@
   enum gearman_con_universal_t state;
   enum gearman_con_send_t send_state;
   enum gearman_con_recv_t recv_state;
-  in_port_t port;
   short events;
   short revents;
   int fd;
@@ -73,7 +74,8 @@
   const char *send_buffer_ptr;
   char *recv_buffer_ptr;
   gearman_packet_st _packet;
-  char host[GEARMAN_NI_MAXHOST];
+  char _host[GEARMAN_NI_MAXHOST];
+  char _service[GEARMAN_NI_MAXSERV];
   char send_buffer[GEARMAN_SEND_BUFFER_SIZE];
   char recv_buffer[GEARMAN_RECV_BUFFER_SIZE];
 
@@ -85,6 +87,7 @@
   ~gearman_connection_st();
 
   void set_host( const char *host, const in_port_t port);
+  void set_host( const char *host, const char* service);
 
   gearman_return_t send_packet(const gearman_packet_st&, const bool flush_buffer);
   size_t send_and_flush(const void *data, size_t data_size, gearman_return_t *ret_ptr);
@@ -133,11 +136,9 @@
  * failed.
  */
 
-GEARMAN_LOCAL
 gearman_connection_st *gearman_connection_create(gearman_universal_st &universal,
-                                                 gearman_connection_options_t *options);
+                                                 gearman_connection_options_t *options= NULL);
 
-GEARMAN_LOCAL
 gearman_connection_st *gearman_connection_copy(gearman_universal_st& universal,
                                                const gearman_connection_st& from);
 
@@ -152,6 +153,8 @@
  * @return On success, a pointer to the (possibly allocated) structure. On
  *  failure this will be NULL.
  */
-GEARMAN_LOCAL
 gearman_connection_st *gearman_connection_create_args(gearman_universal_st &universal,
                                                       const char *host, in_port_t port);
+
+gearman_connection_st *gearman_connection_create_args(gearman_universal_st &universal,
+                                                      const char* host, const char* service);

=== modified file 'libgearman/do.cc'
--- libgearman/do.cc	2012-08-02 05:44:19 +0000
+++ libgearman/do.cc	2012-09-20 02:21:22 +0000
@@ -77,16 +77,20 @@
     return NULL;
   }
 
-  gearman_task_st *do_task_ptr= add_task(*client, &do_task, NULL, command,
-                                         function,
-                                         local_unique,
-                                         workload,
-                                         time_t(0),
-                                         gearman_actions_do_default());
-  if (do_task_ptr == NULL)
   {
-    *ret_ptr= gearman_universal_error_code(client->universal);
-    return NULL;
+    gearman_task_st *do_task_ptr= add_task(*client, &do_task, NULL, command,
+                                           function,
+                                           local_unique,
+                                           workload,
+                                           time_t(0),
+                                           gearman_actions_do_default());
+    if (do_task_ptr == NULL)
+    {
+      *ret_ptr= client->impl()->universal.error_code();
+      return NULL;
+    }
+    assert(do_task_ptr);
+    assert(&do_task == do_task_ptr);
   }
 
   gearman_return_t ret= gearman_client_run_block_tasks(client);
@@ -96,7 +100,7 @@
   // gearman_client_run_block_tasks failed
   if (gearman_failed(ret))
   {
-    gearman_error(client->universal, ret, "occured during gearman_client_run_tasks()");
+    gearman_error(client->impl()->universal, ret, "occured during gearman_client_run_tasks()");
 
     *ret_ptr= ret;
     *result_size= 0;
@@ -104,12 +108,12 @@
   else // Now we check the task itself
   {
     assert(ret == GEARMAN_SUCCESS); // Programmer mistake
-    if (gearman_success(do_task_ptr->result_rc))
+    if (gearman_success(do_task.impl()->result_rc))
     {
-      *ret_ptr= do_task_ptr->result_rc;
-      if (gearman_task_result(do_task_ptr))
+      *ret_ptr= do_task.impl()->result_rc;
+      if (gearman_task_result(&do_task))
       {
-        gearman_string_t result= gearman_result_take_string(do_task_ptr->result_ptr);
+        gearman_string_t result= gearman_result_take_string(do_task.impl()->result_ptr);
         *result_size= gearman_size(result);
         returnable= gearman_c_str(result);
       }
@@ -118,17 +122,17 @@
     }
     else // gearman_client_run_block_tasks() was successful, but the task was not
     {
-      gearman_error(client->universal, do_task_ptr->result_rc, "occured during gearman_client_run_tasks()");
+      gearman_error(client->impl()->universal, do_task.impl()->result_rc, "occured during gearman_client_run_tasks()");
 
-      *ret_ptr= do_task_ptr->result_rc;
+      *ret_ptr= do_task.impl()->result_rc;
       *result_size= 0;
     }
   }
 
-  assert(client->task_list);
+  assert(client->impl()->task_list);
   gearman_task_free(&do_task);
-  client->new_tasks= 0;
-  client->running_tasks= 0;
+  client->impl()->new_tasks= 0;
+  client->impl()->running_tasks= 0;
 
   return const_cast<void *>(returnable);
 }
@@ -146,20 +150,23 @@
   }
 
   gearman_task_st do_task;
-  gearman_task_st *do_task_ptr= add_task(*client, &do_task, 
-                                         client, 
-                                         command,
-                                         function,
-                                         unique,
-                                         workload,
-                                         time_t(0),
-                                         gearman_actions_do_default());
-  if (do_task_ptr == NULL)
   {
-    return gearman_universal_error_code(client->universal);
+    gearman_task_st *do_task_ptr= add_task(*client, &do_task, 
+                                           client, 
+                                           command,
+                                           function,
+                                           unique,
+                                           workload,
+                                           time_t(0),
+                                           gearman_actions_do_default());
+    if (do_task_ptr == NULL)
+    {
+      return client->impl()->universal.error_code();
+    }
+    assert(&do_task == do_task_ptr);
   }
 
-  gearman_task_clear_fn(do_task_ptr);
+  gearman_task_clear_fn(&do_task);
 
   gearman_return_t ret= gearman_client_run_block_tasks(client);
   assert(ret != GEARMAN_IO_WAIT);
@@ -167,10 +174,10 @@
   {
     if (job_handle)
     {
-      strncpy(job_handle, do_task.job_handle, GEARMAN_JOB_HANDLE_SIZE);
+      strncpy(job_handle, do_task.impl()->job_handle, GEARMAN_JOB_HANDLE_SIZE);
     }
-    client->new_tasks= 0;
-    client->running_tasks= 0;
+    client->impl()->new_tasks= 0;
+    client->impl()->running_tasks= 0;
   }
   gearman_task_free(&do_task);
 

=== modified file 'libgearman/error.cc'
--- libgearman/error.cc	2012-08-24 23:45:09 +0000
+++ libgearman/error.cc	2012-09-20 02:21:22 +0000
@@ -48,29 +48,29 @@
 
 static void correct_from_errno(gearman_universal_st& universal)
 {
-  if (universal.error.rc == GEARMAN_ERRNO)
+  if (universal.error_code() == GEARMAN_ERRNO)
   {
-    switch (universal.error.last_errno)
+    switch (universal.last_errno())
     {
     case EFAULT:
     case ENOMEM:
-      universal.error.rc= GEARMAN_MEMORY_ALLOCATION_FAILURE;
+      universal.error_code(GEARMAN_MEMORY_ALLOCATION_FAILURE);
       break;
 
     case EINVAL:
-      universal.error.rc= GEARMAN_INVALID_ARGUMENT;
+      universal.error_code(GEARMAN_INVALID_ARGUMENT);
       break;
 
     case ECONNRESET:
     case EHOSTDOWN:
     case EPIPE:
-      universal.error.rc= GEARMAN_LOST_CONNECTION;
+      universal.error_code(GEARMAN_LOST_CONNECTION);
       break;
 
     case ECONNREFUSED:
     case ENETUNREACH:
     case ETIMEDOUT:
-      universal.error.rc= GEARMAN_COULD_NOT_CONNECT;
+      universal.error_code(GEARMAN_COULD_NOT_CONNECT);
       break;
 
     default:
@@ -79,17 +79,10 @@
   }
   else
   {
-    universal.error.last_errno= 0;
+    universal.last_errno(0);
   }
 }
 
-void universal_reset_error(gearman_universal_st& universal)
-{
-  universal.error.rc= GEARMAN_SUCCESS;
-  universal.error.last_errno= 0;
-  universal.error.last_error[0]= 0;
-}
-
 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
 gearman_return_t gearman_universal_set_error(gearman_universal_st& universal, 
                                              gearman_return_t rc,
@@ -104,7 +97,7 @@
 
   va_list args;
 
-  universal.error.rc= rc;
+  universal._error.rc= rc;
   correct_from_errno(universal);
 
   char last_error[GEARMAN_MAX_ERROR_SIZE];
@@ -116,24 +109,24 @@
   {
     assert(length > int(GEARMAN_MAX_ERROR_SIZE));
     assert(length < 0);
-    universal.error.last_error[GEARMAN_MAX_ERROR_SIZE -1]= 0;
+    universal._error.last_error[GEARMAN_MAX_ERROR_SIZE -1]= 0;
   }
 
-  length= snprintf(universal.error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) %s -> %s", function, gearman_strerror(universal.error.rc), last_error, position);
+  length= snprintf(universal._error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) %s -> %s", function, gearman_strerror(universal._error.rc), last_error, position);
   if (length > int(GEARMAN_MAX_ERROR_SIZE) or length < 0)
   {
     assert(length > int(GEARMAN_MAX_ERROR_SIZE));
     assert(length < 0);
-    universal.error.last_error[GEARMAN_MAX_ERROR_SIZE -1]= 0;
+    universal._error.last_error[GEARMAN_MAX_ERROR_SIZE -1]= 0;
   }
 
   if (universal.log_fn)
   {
-    universal.log_fn(universal.error.last_error, GEARMAN_VERBOSE_FATAL,
+    universal.log_fn(universal._error.last_error, GEARMAN_VERBOSE_FATAL,
                      static_cast<void *>(universal.log_context));
   }
 
-  return universal.error.rc;
+  return universal._error.rc;
 }
 
 gearman_return_t gearman_universal_set_gerror(gearman_universal_st& universal, 
@@ -146,21 +139,21 @@
     return rc;
   }
 
-  universal.error.rc= rc;
+  universal._error.rc= rc;
   correct_from_errno(universal);
 
-  int length= snprintf(universal.error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) -> %s", func, gearman_strerror(rc), position);
+  int length= snprintf(universal._error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) -> %s", func, gearman_strerror(rc), position);
   if (length > int(GEARMAN_MAX_ERROR_SIZE) or length < 0)
   {
     assert(length > int(GEARMAN_MAX_ERROR_SIZE));
     assert(length < 0);
-    universal.error.last_error[GEARMAN_MAX_ERROR_SIZE -1]= 0;
+    universal._error.last_error[GEARMAN_MAX_ERROR_SIZE -1]= 0;
     return GEARMAN_ARGUMENT_TOO_LARGE;
   }
 
   if (universal.log_fn)
   {
-    universal.log_fn(universal.error.last_error, GEARMAN_VERBOSE_FATAL,
+    universal.log_fn(universal._error.last_error, GEARMAN_VERBOSE_FATAL,
                      static_cast<void *>(universal.log_context));
   }
 
@@ -179,14 +172,14 @@
   switch (errno)
   {
   case ENOMEM:
-    universal.error.rc= GEARMAN_MEMORY_ALLOCATION_FAILURE;
+    universal._error.rc= GEARMAN_MEMORY_ALLOCATION_FAILURE;
     break;
 
   default:
-    universal.error.rc= GEARMAN_ERRNO;
+    universal._error.rc= GEARMAN_ERRNO;
     break;
   }
-  universal.error.last_errno= errno;
+  universal._error.last_errno= errno;
 
   correct_from_errno(universal);
 
@@ -195,34 +188,34 @@
   errmsg[0]= 0; 
 
 #ifdef STRERROR_R_CHAR_P
-  errmsg_ptr= strerror_r(universal.error.last_errno, errmsg, sizeof(errmsg));
+  errmsg_ptr= strerror_r(universal._error.last_errno, errmsg, sizeof(errmsg));
 #else
-  strerror_r(universal.error.last_errno, errmsg, sizeof(errmsg));
+  strerror_r(universal._error.last_errno, errmsg, sizeof(errmsg));
   errmsg_ptr= errmsg;
 #endif
 
   int length;
   if (message)
   {
-    length= snprintf(universal.error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) %s -> %s", function, errmsg_ptr, message, position);
+    length= snprintf(universal._error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) %s -> %s", function, errmsg_ptr, message, position);
   }
   else
   {
-    length= snprintf(universal.error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) -> %s", function, errmsg_ptr, position);
+    length= snprintf(universal._error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) -> %s", function, errmsg_ptr, position);
   }
 
   if (length > int(GEARMAN_MAX_ERROR_SIZE) or length < 0)
   {
     assert(length > int(GEARMAN_MAX_ERROR_SIZE));
     assert(length < 0);
-    universal.error.last_error[GEARMAN_MAX_ERROR_SIZE -1]= 0;
+    universal._error.last_error[GEARMAN_MAX_ERROR_SIZE -1]= 0;
   }
 
   if (universal.log_fn)
   {
-    universal.log_fn(universal.error.last_error, GEARMAN_VERBOSE_FATAL,
+    universal.log_fn(universal._error.last_error, GEARMAN_VERBOSE_FATAL,
                      static_cast<void *>(universal.log_context));
   }
 
-  return universal.error.rc;
+  return universal._error.rc;
 }

=== modified file 'libgearman/error.hpp'
--- libgearman/error.hpp	2012-09-16 00:30:28 +0000
+++ libgearman/error.hpp	2012-09-20 02:21:22 +0000
@@ -62,7 +62,10 @@
                                               gearman_return_t rc,
                                               const char *func,
                                               const char *position);
+<<<<<<< TREE
 
 void universal_reset_error(gearman_universal_st& universal);
 
 void gearman_worker_reset_error(gearman_worker_st *worker);
+=======
+>>>>>>> MERGE-SOURCE

=== modified file 'libgearman/execute.cc'
--- libgearman/execute.cc	2012-08-02 05:44:19 +0000
+++ libgearman/execute.cc	2012-09-20 02:21:22 +0000
@@ -86,7 +86,7 @@
 
   if (function_name == NULL or function_length == 0)
   {
-    gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "function_name was NULL");
+    gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "function_name was NULL");
     return NULL;
   }
   gearman_string_t function= { function_name, function_length };
@@ -145,12 +145,12 @@
 
   if (task == NULL)
   {
-    gearman_universal_error_code(client->universal);
+    gearman_universal_error_code(client->impl()->universal);
 
     return NULL;
   }
 
-  task->type= GEARMAN_TASK_KIND_EXECUTE;
+  task->impl()->type= GEARMAN_TASK_KIND_EXECUTE;
   gearman_client_run_tasks(client);
 
   return task;
@@ -172,17 +172,17 @@
 
   if ((partition_function == NULL) or (partition_function_length == 0))
   {
-    gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "function_name was NULL");
+    gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "function_name was NULL");
     return NULL;
   }
 
   if ((function_name == NULL) or (function_name_length == 0))
   {
-    gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "function_name was NULL");
+    gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "function_name was NULL");
     return NULL;
   }
   
-  universal_reset_error(client->universal);
+  universal_reset_error(client->impl()->universal);
 
   gearman_task_st *task= NULL;
   gearman_string_t partition= { partition_function, partition_function_length };
@@ -207,7 +207,7 @@
       break;
 
     case GEARMAN_TASK_ATTR_EPOCH:
-      gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "EPOCH is not currently supported for gearman_client_execute_reduce()");
+      gearman_error(client->impl()->universal, GEARMAN_INVALID_ARGUMENT, "EPOCH is not currently supported for gearman_client_execute_reduce()");
       return NULL;
 #if 0
       task= add_task(client,
@@ -260,7 +260,7 @@
     gearman_return_t rc;
     if (gearman_failed(rc= gearman_client_run_tasks(client)))
     {
-      gearman_gerror(client->universal, rc);
+      gearman_gerror(client->impl()->universal, rc);
       gearman_task_free(task);
       return NULL;
     }

=== modified file 'libgearman/function/function_v1.hpp'
--- libgearman/function/function_v1.hpp	2012-04-17 05:48:26 +0000
+++ libgearman/function/function_v1.hpp	2012-09-20 02:21:22 +0000
@@ -63,7 +63,7 @@
     }
 
     job->error_code= GEARMAN_SUCCESS;
-    job->worker->work_result= _worker_fn(job, context_arg, &(job->worker->work_result_size), &job->error_code);
+    job->worker->impl()->work_result= _worker_fn(job, context_arg, &(job->worker->impl()->work_result_size), &job->error_code);
 
     if (job->error_code == GEARMAN_LOST_CONNECTION)
     {

=== modified file 'libgearman/include.am'
--- libgearman/include.am	2012-08-16 10:51:22 +0000
+++ libgearman/include.am	2012-09-20 02:21:22 +0000
@@ -12,7 +12,14 @@
 
 nobase_include_HEADERS+= libgearman/gearman.h
 
+noinst_HEADERS+= libgearman/interface/packet.hpp
+noinst_HEADERS+= libgearman/interface/universal.hpp
+noinst_HEADERS+= libgearman/interface/client.hpp
+noinst_HEADERS+= libgearman/interface/push.hpp
+noinst_HEADERS+= libgearman/interface/task.hpp
+noinst_HEADERS+= libgearman/interface/worker.hpp
 noinst_HEADERS+= libgearman/uuid.hpp
+noinst_HEADERS+= libgearman/job.hpp
 noinst_HEADERS+= libgearman/job.h
 noinst_HEADERS+= libgearman/pipe.h
 noinst_HEADERS+= \

=== added directory 'libgearman/interface'
=== added file 'libgearman/interface/client.hpp'
--- libgearman/interface/client.hpp	1970-01-01 00:00:00 +0000
+++ libgearman/interface/client.hpp	2012-09-20 02:21:22 +0000
@@ -0,0 +1,118 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Gearmand client and server library.
+ *
+ *  Copyright (C) 2012 Data Differential, http://datadifferential.com/
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#pragma once
+
+#include "libgearman/actions.hpp"
+#include "libgearman/interface/universal.hpp"
+#include "libgearman/is.hpp"
+
+struct Client
+{
+  struct Options {
+    bool non_blocking;
+    bool unbuffered_result;
+    bool no_new;
+    bool free_tasks;
+
+    Options():
+      non_blocking(false),
+      unbuffered_result(false),
+      no_new(false),
+      free_tasks(false)
+    {
+    }
+  } options;
+  enum gearman_client_t state;
+  uint32_t new_tasks;
+  uint32_t running_tasks;
+  uint32_t task_count;
+  void *context;
+  struct gearman_connection_st *con;
+  gearman_task_st *task;
+  gearman_task_st *task_list;
+  gearman_task_context_free_fn *task_context_free_fn;
+  gearman_universal_st universal;
+  struct gearman_actions_t actions;
+  gearman_job_handle_t _do_handle; // Backwards compatible
+
+
+  Client(gearman_client_st* shell_) :
+    state(GEARMAN_CLIENT_STATE_IDLE),
+    new_tasks(0),
+    running_tasks(0),
+    task_count(0),
+    context(NULL),
+    con(NULL),
+    task(NULL),
+    task_list(NULL),
+    task_context_free_fn(NULL),
+    actions(gearman_actions_default()),
+    _shell(shell_)
+  {
+    _do_handle[0]= 0;
+
+    if (shell_)
+    {
+      gearman_set_allocated(_shell, false);
+    }
+    else
+    {
+      _shell= &_owned_shell;
+      gearman_set_allocated(_shell, true);
+    }
+
+    _shell->impl(this);
+    gearman_set_initialized(_shell, true);
+  }
+
+  gearman_return_t add_server(const char *host, const char* service_);
+
+  ~Client()
+  {
+  }
+
+  gearman_client_st* shell()
+  {
+    return _shell;
+  }
+
+private:
+  gearman_client_st* _shell;
+  gearman_client_st _owned_shell;
+};
+

=== renamed file 'libgearman-1.0/packet.h' => 'libgearman/interface/packet.hpp'
--- libgearman-1.0/packet.h	2012-04-02 07:03:19 +0000
+++ libgearman/interface/packet.hpp	2012-09-20 02:21:22 +0000
@@ -2,7 +2,7 @@
  * 
  *  Gearmand client and server library.
  *
- *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ *  Copyright (C) 2011-2012 Data Differential, http://datadifferential.com/
  *  Copyright (C) 2008 Brian Aker, Eric Day
  *  All rights reserved.
  *
@@ -45,22 +45,30 @@
   GEARMAN_MAGIC_RESPONSE
 };
 
+struct gearman_universal_st;
+
 /**
  * @ingroup gearman_packet
  */
 struct gearman_packet_st
 {
-  struct {
-    bool allocated;
+  struct Options {
+    bool is_allocated;
     bool complete;
     bool free_data;
+
+    Options() :
+      is_allocated(false),
+      complete(false),
+      free_data(false)
+    { }
   } options;
   enum gearman_magic_t magic;
   gearman_command_t command;
   uint8_t argc;
   size_t args_size;
   size_t data_size;
-  struct gearman_universal_st *universal;
+  gearman_universal_st *universal;
   gearman_packet_st *next;
   gearman_packet_st *prev;
   char *args;
@@ -71,4 +79,18 @@
 #ifdef GEARMAN_PACKET_TRACE
   uint32_t _id;
 #endif
+
+  gearman_packet_st() :
+    magic(GEARMAN_MAGIC_TEXT),
+    command(GEARMAN_COMMAND_TEXT),
+    argc(0),
+    args_size(0),
+    data_size(0),
+    universal(0),
+    next(0),
+    prev(0),
+    args(0),
+    data(0)
+  {
+  }
 };

=== added file 'libgearman/interface/push.hpp'
--- libgearman/interface/push.hpp	1970-01-01 00:00:00 +0000
+++ libgearman/interface/push.hpp	2012-09-20 02:21:22 +0000
@@ -0,0 +1,102 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Gearmand client and server library.
+ *
+ *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ *  Copyright (C) 2008 Brian Aker, Eric Day
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#pragma once
+
+#include "libgearman/interface/client.hpp" 
+#include "libgearman/interface/universal.hpp" 
+
+/**
+  Push the state of IO
+*/
+class PushBlocking {
+public:
+  PushBlocking(gearman_universal_st& arg) :
+    _original(arg.options.non_blocking),
+    _universal(arg)
+  {
+    _universal.non_blocking(false);
+  }
+
+  PushBlocking(gearman_client_st* client_shell) :
+    _original(client_shell->impl()->universal.is_non_blocking()),
+    _universal(client_shell->impl()->universal)
+  {
+    _universal.non_blocking(false);
+  }
+
+  ~PushBlocking()
+  {
+    _universal.non_blocking(_original);
+  }
+
+private:
+  bool _original;
+  gearman_universal_st& _universal;
+};
+
+#define PUSH_BLOCKING(__univeral) PushBlocking _push_block((__univeral));
+
+class PushNonBlocking {
+public:
+  PushNonBlocking(gearman_universal_st& arg) :
+    _original(arg.options.non_blocking),
+    _universal(arg)
+  {
+    _universal.non_blocking(true);
+  }
+
+  PushNonBlocking(gearman_client_st* client_shell) :
+    _original(client_shell->impl()->universal.options.non_blocking),
+    _universal(client_shell->impl()->universal)
+  {
+    _universal.non_blocking(true);
+  }
+
+  ~PushNonBlocking()
+  {
+    _universal.non_blocking(_original);
+  }
+
+private:
+  bool _original;
+  gearman_universal_st& _universal;
+};
+
+#define PUSH_NON_BLOCKING(__univeral) PushNonBlocking _push_block((__univeral));
+

=== added file 'libgearman/interface/task.hpp'
--- libgearman/interface/task.hpp	1970-01-01 00:00:00 +0000
+++ libgearman/interface/task.hpp	2012-09-20 02:21:22 +0000
@@ -0,0 +1,143 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Gearmand client and server library.
+ *
+ *  Copyright (C) 2012 Data Differential, http://datadifferential.com/
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#pragma once
+
+#include "libgearman/interface/client.hpp"
+#include "libgearman/interface/packet.hpp"
+
+#define TASK_MAGIC 134
+#define TASK_ANTI_MAGIC 157
+
+struct Task
+{
+  struct Options {
+    bool send_in_use;
+    bool is_known;
+    bool is_running;
+    bool was_reduced;
+    bool is_paused;
+    bool is_initialized;
+
+    Options() :
+      send_in_use(false),
+      is_known(false),
+      is_running(false),
+      was_reduced(false),
+      is_paused(false),
+      is_initialized(true)
+    { }
+  } options;
+  enum gearman_task_kind_t type;
+  enum gearman_task_state_t state;
+  uint32_t magic_;
+  uint32_t created_id;
+  uint32_t numerator;
+  uint32_t denominator;
+  uint32_t client_count;
+  gearman_client_st *client;
+  gearman_task_st *next;
+  gearman_task_st *prev;
+  void *context;
+  gearman_connection_st *con;
+  gearman_packet_st *recv;
+  gearman_packet_st send;
+  struct gearman_actions_t func;
+  gearman_return_t result_rc;
+  struct gearman_result_st *result_ptr;
+  char job_handle[GEARMAN_JOB_HANDLE_SIZE];
+  size_t unique_length;
+  char unique[GEARMAN_MAX_UNIQUE_SIZE];
+
+  gearman_task_st* shell()
+  {
+    return _shell;
+  }
+
+  Task(gearman_client_st& client_, gearman_task_st* shell_) :
+    type(GEARMAN_TASK_KIND_ADD_TASK),
+    state(GEARMAN_TASK_STATE_NEW),
+    magic_(TASK_MAGIC),
+    created_id(0),
+    numerator(0),
+    denominator(0),
+    client_count(0),
+    client(&client_),
+    next(NULL),
+    prev(NULL),
+    context(NULL),
+    con(NULL),
+    recv(NULL),
+    func(client_.impl()->actions),
+    result_rc(GEARMAN_UNKNOWN_STATE),
+    result_ptr(NULL),
+    unique_length(0),
+    _shell(shell_)
+  {
+    job_handle[0]= 0;
+    unique[0]= 0;
+
+    if (_shell)
+    {
+      gearman_set_allocated(_shell, false);
+    }
+    else
+    {
+      _shell= &_owned_shell;
+      gearman_set_allocated(_shell, true);
+    }
+    gearman_set_initialized(_shell, true);
+
+    // Add the task to the client
+    {
+      if (client_.impl()->task_list)
+      {
+        client_.impl()->task_list->impl()->prev= _shell;
+      }
+      next= client_.impl()->task_list;
+      prev= NULL;
+      client_.impl()->task_list= _shell;
+      client_.impl()->task_count++;
+    }
+
+    _shell->impl(this);
+  }
+
+private:
+  gearman_task_st* _shell;
+  gearman_task_st _owned_shell;
+};

=== renamed file 'libgearman-1.0/universal.h' => 'libgearman/interface/universal.hpp'
--- libgearman-1.0/universal.h	2012-05-27 02:15:15 +0000
+++ libgearman/interface/universal.hpp	2012-09-20 02:21:22 +0000
@@ -38,7 +38,7 @@
 
 #pragma once
 
-#include <libgearman-1.0/allocator.h>
+#include "libgearman/allocator.hpp" 
 
 /**
   @todo this is only used by the server and should be made private.
@@ -47,14 +47,16 @@
 typedef gearman_return_t (gearman_event_watch_fn)(gearman_connection_st *con,
                                                   short events, void *context);
 
-/**
- * @ingroup gearman_universal
- */
 struct gearman_universal_st
 {
-  struct {
+  struct Options {
     bool dont_track_packets;
     bool non_blocking;
+
+    Options() :
+      dont_track_packets(false),
+      non_blocking(false)
+    { }
   } options;
   gearman_verbose_t verbose;
   uint32_t con_count;
@@ -63,16 +65,146 @@
   uint32_t sending;
   int timeout; // Used by poll()
   gearman_connection_st *con_list;
-  gearman_packet_st *packet_list;
+  struct gearman_packet_st *packet_list;
   struct pollfd *pfds;
   gearman_log_fn *log_fn;
   void *log_context;
   gearman_allocator_t allocator;
   struct gearman_vector_st *_namespace;
-  struct {
+  struct error_st {
     gearman_return_t rc;
     int last_errno;
     char last_error[GEARMAN_MAX_ERROR_SIZE];
-  } error;
+
+    error_st():
+      rc(GEARMAN_SUCCESS),
+      last_errno(0)
+    {
+      last_error[0]= 0;
+    }
+
+  } _error;
   int wakeup_fd[2];
+
+  bool is_non_blocking() const
+  {
+    return options.non_blocking;
+  }
+
+  void non_blocking(bool arg_)
+  {
+    options.non_blocking= arg_;
+  }
+
+  const char *error() const
+  {
+    if (_error.last_error[0] == 0)
+    {
+      return NULL;
+    }
+
+    return static_cast<const char *>(_error.last_error);
+  }
+
+  gearman_return_t error_code() const
+  {
+    return _error.rc;
+  }
+
+  void error_code(gearman_return_t rc)
+  {
+    _error.rc= rc;
+  }
+
+  int last_errno() const
+  {
+    return _error.last_errno;
+  }
+
+  void last_errno(int last_errno_)
+  {
+    _error.last_errno= last_errno_;
+  }
+
+  void reset_error()
+  {
+    _error.rc= GEARMAN_SUCCESS;
+    _error.last_errno= 0;
+    _error.last_error[0]= 0;
+  }
+
+  gearman_return_t option(gearman_universal_options_t option_, bool value)
+  {
+    switch (option_)
+    {
+    case GEARMAN_NON_BLOCKING:
+      non_blocking(value);
+      break;
+
+    case GEARMAN_DONT_TRACK_PACKETS:
+      break;
+
+    case GEARMAN_MAX:
+    default:
+      return GEARMAN_INVALID_COMMAND;
+    }
+
+    return GEARMAN_SUCCESS;
+  }
+
+  gearman_universal_st(const gearman_universal_options_t *options_= NULL) :
+    verbose(GEARMAN_VERBOSE_NEVER),
+    con_count(0),
+    packet_count(0),
+    pfds_size(0),
+    sending(0),
+    timeout(-1),
+    con_list(NULL),
+    packet_list(NULL),
+    pfds(NULL),
+    log_fn(NULL),
+    log_context(NULL),
+    allocator(gearman_default_allocator()),
+    _namespace(NULL)
+  {
+    wakeup_fd[0]= INVALID_SOCKET;
+    wakeup_fd[1]= INVALID_SOCKET;
+
+    if (options_)
+    {
+      while (*options_ != GEARMAN_MAX)
+      {
+        /**
+          @note Check for bad value, refactor gearman_add_options().
+        */
+        (void)option(*options_, true);
+        options_++;
+      }
+    }
+  }
 };
+
+static inline bool gearman_universal_is_non_blocking(gearman_universal_st &self)
+{
+  return self.is_non_blocking();
+}
+
+static inline const char *gearman_universal_error(const gearman_universal_st &self)
+{
+  return self.error();
+}
+
+static inline gearman_return_t gearman_universal_error_code(const gearman_universal_st &self)
+{
+  return self.error_code();
+}
+
+static inline int gearman_universal_errno(const gearman_universal_st &self)
+{
+  return self.last_errno();
+}
+
+static inline void universal_reset_error(gearman_universal_st &self)
+{
+  self.reset_error();
+}

=== added file 'libgearman/interface/worker.hpp'
--- libgearman/interface/worker.hpp	1970-01-01 00:00:00 +0000
+++ libgearman/interface/worker.hpp	2012-09-20 02:21:22 +0000
@@ -0,0 +1,124 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Gearmand client and server library.
+ *
+ *  Copyright (C) 2012 Data Differential, http://datadifferential.com/
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#pragma once
+
+#include "libgearman/interface/universal.hpp"
+#include "libgearman/interface/packet.hpp"
+
+struct Worker
+{
+  struct Options {
+    bool non_blocking;
+    bool packet_init;
+    bool change;
+    bool grab_uniq;
+    bool grab_all;
+    bool timeout_return;
+
+    Options() :
+      non_blocking(false),
+      packet_init(false),
+      change(false),
+      grab_uniq(true),
+      grab_all(true),
+      timeout_return(false)
+    { }
+  } options;
+  enum gearman_worker_state_t state;
+  enum gearman_worker_universal_t work_state;
+  uint32_t function_count;
+  uint32_t job_count;
+  size_t work_result_size;
+  void *context;
+  gearman_connection_st *con;
+  gearman_job_st *job;
+  gearman_job_st *job_list;
+  struct _worker_function_st *function;
+  struct _worker_function_st *function_list;
+  struct _worker_function_st *work_function;
+  void *work_result;
+  struct gearman_universal_st universal;
+  gearman_packet_st grab_job;
+  gearman_packet_st pre_sleep;
+  gearman_job_st *work_job;
+
+  Worker(gearman_worker_st* shell_) :
+    state(GEARMAN_WORKER_STATE_START),
+    work_state(GEARMAN_WORKER_WORK_UNIVERSAL_GRAB_JOB),
+    function_count(0),
+    job_count(0),
+    work_result_size(0),
+    context(NULL),
+    con(NULL),
+    job(NULL),
+    job_list(NULL),
+    function(NULL),
+    function_list(NULL),
+    work_function(NULL),
+    work_result(NULL),
+    work_job(NULL),
+    _shell(shell_)
+  {
+    if (shell_)
+    {
+      gearman_set_allocated(_shell, false);
+    }
+    else
+    {
+      _shell= &_owned_shell;
+      gearman_set_allocated(_shell, true);
+    }
+
+    _shell->impl(this);
+    gearman_set_initialized(_shell, true);
+  }
+
+  ~Worker()
+  {
+  }
+
+  gearman_worker_st* shell()
+  {
+    return _shell;
+  }
+
+private:
+  gearman_worker_st* _shell;
+  gearman_worker_st _owned_shell;
+};
+

=== modified file 'libgearman/is.hpp'
--- libgearman/is.hpp	2012-07-09 09:07:43 +0000
+++ libgearman/is.hpp	2012-09-20 02:21:22 +0000
@@ -42,6 +42,7 @@
 #define gearman_is_initialized(__object) ((__object)->options.is_initialized)
 #define gearman_is_purging(__object) ((__object)->state.is_purging)
 #define gearman_is_processing_input(__object) ((__object)->state.is_processing_input)
+#define gearman_is_non_blocking(__object) ((__object)->options.non_blocking)
 #define gearman_set_purging(__object, __value) ((__object)->state.is_purging= (__value))
 #define gearman_set_processing_input(__object, __value) ((__object)->state.is_processing_input= (__value))
 #define gearman_set_initialized(__object, __value) ((__object)->options.is_initialized= (__value))

=== modified file 'libgearman/job.cc'
--- libgearman/job.cc	2012-09-16 00:30:28 +0000
+++ libgearman/job.cc	2012-09-20 02:21:22 +0000
@@ -76,7 +76,9 @@
   {
     client= gearman_client_create(NULL);
     if (not client)
+    {
       return false;
+    }
 
     if (universal._namespace)
     {
@@ -87,7 +89,7 @@
 
     for (gearman_connection_st *con= universal.con_list; con; con= con->next)
     {
-      if (gearman_failed(gearman_client_add_server(client, con->host, con->port)))
+      if (gearman_failed(client->impl()->add_server(con->_host, con->_service)))
       {
         return false;
       }
@@ -110,7 +112,7 @@
                                     gearman_actions_execute_defaults());
     if (task == NULL)
     {
-      gearman_universal_error_code(client->universal);
+      gearman_universal_error_code(client->impl()->universal);
 
       return false;
     }
@@ -126,22 +128,22 @@
       return rc;
     }
 
-    gearman_task_st *check_task= client->task_list;
+    gearman_task_st *check_task= client->impl()->task_list;
 
     if (check_task)
     {
       do
       {
-        if (gearman_failed(check_task->result_rc))
+        if (gearman_failed(check_task->impl()->result_rc))
         {
-          return check_task->result_rc;
+          return check_task->impl()->result_rc;
         }
       } while ((check_task= gearman_next(check_task)));
 
       if (aggregator_fn)
       {
-        gearman_aggregator_st aggregator(client->context);
-        aggregator_fn(&aggregator, client->task_list, &result);
+        gearman_aggregator_st aggregator(client->impl()->context);
+        aggregator_fn(&aggregator, client->impl()->task_list, &result);
       }
     }
 
@@ -173,9 +175,9 @@
   else
   {
     job= new (std::nothrow) gearman_job_st;
-    if (not job)
+    if (job == NULL)
     {
-      gearman_perror(worker->universal, "new");
+      gearman_perror(worker->impl()->universal, "new");
       return NULL;
     }
 
@@ -190,14 +192,14 @@
   job->reducer= NULL;
   job->error_code= GEARMAN_UNKNOWN_STATE;
 
-  if (worker->job_list)
+  if (worker->impl()->job_list)
   {
-    worker->job_list->prev= job;
+    worker->impl()->job_list->prev= job;
   }
-  job->next= worker->job_list;
+  job->next= worker->impl()->job_list;
   job->prev= NULL;
-  worker->job_list= job;
-  worker->job_count++;
+  worker->impl()->job_list= job;
+  worker->impl()->job_count++;
 
   job->con= NULL;
 
@@ -213,7 +215,7 @@
 
   gearman_string_t reducer_func= gearman_job_reducer_string(job);
 
-  job->reducer= new (std::nothrow) gearman_job_reducer_st(job->worker->universal, reducer_func, aggregator_fn);
+  job->reducer= new (std::nothrow) gearman_job_reducer_st(job->worker->impl()->universal, reducer_func, aggregator_fn);
   if (not job->reducer)
   {
     gearman_job_free(job);
@@ -256,7 +258,7 @@
     args_size[0]= job->assigned.arg_size[0];
     args[1]= data;
     args_size[1]= data_size;
-    gearman_return_t ret= gearman_packet_create_args(job->worker->universal, job->work,
+    gearman_return_t ret= gearman_packet_create_args(job->worker->impl()->universal, job->work,
                                                      GEARMAN_MAGIC_REQUEST,
                                                      GEARMAN_COMMAND_WORK_DATA,
                                                      args, args_size, 2);
@@ -286,7 +288,7 @@
     args_size[1]= warning_size;
 
     gearman_return_t ret;
-    ret= gearman_packet_create_args(job->worker->universal, job->work,
+    ret= gearman_packet_create_args(job->worker->impl()->universal, job->work,
                                     GEARMAN_MAGIC_REQUEST,
                                     GEARMAN_COMMAND_WORK_WARNING,
                                     args, args_size, 2);
@@ -323,7 +325,7 @@
     args_size[2]= strlen(denominator_string);
 
     gearman_return_t ret;
-    ret= gearman_packet_create_args(job->worker->universal, job->work,
+    ret= gearman_packet_create_args(job->worker->impl()->universal, job->work,
                                     GEARMAN_MAGIC_REQUEST,
                                     GEARMAN_COMMAND_WORK_STATUS,
                                     args, args_size, 3);
@@ -369,7 +371,7 @@
     gearman_return_t rc= job->reducer->complete();
     if (gearman_failed(rc))
     {
-      return gearman_error(job->worker->universal, rc, "The reducer's complete() returned an error");
+      return gearman_error(job->worker->impl()->universal, rc, "The reducer's complete() returned an error");
     }
 
     gearman_vector_st *reduced_value= job->reducer->result.string();
@@ -395,7 +397,7 @@
 
     args[1]= result;
     args_size[1]= result_size;
-    gearman_return_t ret= gearman_packet_create_args(job->worker->universal, job->work,
+    gearman_return_t ret= gearman_packet_create_args(job->worker->impl()->universal, job->work,
                                                      GEARMAN_MAGIC_REQUEST,
                                                      GEARMAN_COMMAND_WORK_COMPLETE,
                                                      args, args_size, 2);
@@ -431,7 +433,7 @@
     args[1]= exception;
     args_size[1]= exception_size;
 
-    gearman_return_t ret= gearman_packet_create_args(job->worker->universal, job->work,
+    gearman_return_t ret= gearman_packet_create_args(job->worker->impl()->universal, job->work,
                                                      GEARMAN_MAGIC_REQUEST,
                                                      GEARMAN_COMMAND_WORK_EXCEPTION,
                                                      args, args_size, 2);
@@ -466,7 +468,7 @@
   {
     args[0]= job->assigned.arg[0];
     args_size[0]= job->assigned.arg_size[0] - 1;
-    gearman_return_t ret= gearman_packet_create_args(job->worker->universal, job->work,
+    gearman_return_t ret= gearman_packet_create_args(job->worker->impl()->universal, job->work,
                                                      GEARMAN_MAGIC_REQUEST,
                                                      GEARMAN_COMMAND_WORK_FAIL,
                                                      args, args_size, 1);
@@ -572,9 +574,9 @@
     gearman_packet_free(&(job->work));
   }
 
-  if (job->worker->job_list == job)
+  if (job->worker->impl()->job_list == job)
   {
-    job->worker->job_list= job->next;
+    job->worker->impl()->job_list= job->next;
   }
 
   if (job->prev)
@@ -586,7 +588,7 @@
   {
     job->next->prev= job->prev;
   }
-  job->worker->job_count--;
+  job->worker->impl()->job_count--;
 
   delete job->reducer;
   job->reducer= NULL;
@@ -607,11 +609,15 @@
 
   while ((ret == GEARMAN_IO_WAIT) or (ret == GEARMAN_TIMEOUT))
   {
+<<<<<<< TREE
 #if 0
     assert(job->work.universal);
     ret= gearman_wait(*(job->work.universal));
 #endif
     ret= gearman_wait(job->worker->universal);
+=======
+    ret= gearman_wait(job->worker->impl()->universal);
+>>>>>>> MERGE-SOURCE
     if (ret == GEARMAN_SUCCESS)
     {
       ret= job->con->send_packet(job->work, true);

=== added file 'libgearman/job.hpp'
--- libgearman/job.hpp	1970-01-01 00:00:00 +0000
+++ libgearman/job.hpp	2012-09-20 02:21:22 +0000
@@ -0,0 +1,56 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Gearmand client and server library.
+ *
+ *  Copyright (C) 2012 Data Differential, http://datadifferential.com/
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#pragma once
+
+struct gearman_job_st
+{
+  struct {
+    bool allocated;
+    bool assigned_in_use;
+    bool work_in_use;
+    bool finished;
+  } options;
+  gearman_worker_st *worker;
+  gearman_job_st *next;
+  gearman_job_st *prev;
+  gearman_connection_st *con;
+  gearman_packet_st assigned;
+  gearman_packet_st work;
+  struct gearman_job_reducer_st *reducer;
+  gearman_return_t error_code;
+};

=== modified file 'libgearman/packet.cc'
--- libgearman/packet.cc	2012-05-27 02:38:08 +0000
+++ libgearman/packet.cc	2012-09-20 02:21:22 +0000
@@ -159,7 +159,7 @@
 {
   if (packet)
   {
-    packet->options.allocated= false;
+    gearman_set_allocated(packet, false);
     packet->options.complete= false;
     packet->options.free_data= false;
   }
@@ -173,7 +173,7 @@
       return NULL;
     }
 
-    packet->options.allocated= true;
+    gearman_set_allocated(packet, true);
   }
   packet->options.complete= false;
   packet->options.free_data= false;
@@ -319,7 +319,7 @@
     packet->universal->packet_count--;
   }
 
-  if (packet->options.allocated)
+  if (gearman_is_allocated(packet))
   {
     delete packet;
   }

=== modified file 'libgearman/protocol/submit.cc'
--- libgearman/protocol/submit.cc	2012-08-11 01:53:36 +0000
+++ libgearman/protocol/submit.cc	2012-09-20 02:21:22 +0000
@@ -43,7 +43,7 @@
 namespace libgearman {
 namespace protocol {
 
-static inline gearman_return_t __submit(gearman_task_st& task,
+static inline gearman_return_t __submit(Task& task,
                                         const gearman_command_t command,
                                         const gearman_string_t &function,
                                         const gearman_string_t &workload)
@@ -55,11 +55,12 @@
     @todo fix it so that NULL is done by default by the API not by happenstance.
   */
   char function_buffer[1024];
-  if (task.client->universal._namespace)
+  assert(task.client);
+  if (task.client->impl()->universal._namespace)
   {
     char *ptr= function_buffer;
-    memcpy(ptr, gearman_string_value(task.client->universal._namespace), gearman_string_length(task.client->universal._namespace)); 
-    ptr+= gearman_string_length(task.client->universal._namespace);
+    memcpy(ptr, gearman_string_value(task.client->impl()->universal._namespace), gearman_string_length(task.client->impl()->universal._namespace)); 
+    ptr+= gearman_string_length(task.client->impl()->universal._namespace);
 
     memcpy(ptr, gearman_c_str(function), gearman_size(function) +1);
     ptr+= gearman_size(function);
@@ -79,14 +80,14 @@
   args[2]= gearman_c_str(workload);
   args_size[2]= gearman_size(workload);
 
-  return gearman_packet_create_args(task.client->universal, task.send,
+  return gearman_packet_create_args(task.client->impl()->universal, task.send,
                                     GEARMAN_MAGIC_REQUEST,
                                     command,
                                     args, args_size,
                                     3);
 }
 
-gearman_return_t submit(gearman_task_st& task,
+gearman_return_t submit(Task& task,
                         const gearman_command_t command,
                         const gearman_string_t &function,
                         const gearman_string_t &workload)
@@ -94,7 +95,7 @@
   return __submit(task, command, function, workload);
 }
 
-gearman_return_t submit_background(gearman_task_st& task,
+gearman_return_t submit_background(Task& task,
                                    const gearman_command_t command,
                                    const gearman_string_t &function,
                                    const gearman_string_t &workload)
@@ -102,7 +103,7 @@
   return __submit(task, command, function, workload);
 }
 
-gearman_return_t submit_epoch(gearman_task_st& task,
+gearman_return_t submit_epoch(Task& task,
                               const gearman_string_t &function,
                               const gearman_string_t &workload,
                               time_t when)
@@ -114,11 +115,11 @@
     @todo fix it so that NULL is done by default by the API not by happenstance.
   */
   char function_buffer[1024];
-  if (task.client->universal._namespace)
+  if (task.client->impl()->universal._namespace)
   {
     char *ptr= function_buffer;
-    memcpy(ptr, gearman_string_value(task.client->universal._namespace), gearman_string_length(task.client->universal._namespace)); 
-    ptr+= gearman_string_length(task.client->universal._namespace);
+    memcpy(ptr, gearman_string_value(task.client->impl()->universal._namespace), gearman_string_length(task.client->impl()->universal._namespace)); 
+    ptr+= gearman_string_length(task.client->impl()->universal._namespace);
 
     memcpy(ptr, gearman_c_str(function), gearman_size(function) +1);
     ptr+= gearman_size(function);
@@ -143,7 +144,7 @@
   args[3]= gearman_c_str(workload);
   args_size[3]= gearman_size(workload);
 
-  return gearman_packet_create_args(task.client->universal, task.send,
+  return gearman_packet_create_args(task.client->impl()->universal, task.send,
                                     GEARMAN_MAGIC_REQUEST,
                                     GEARMAN_COMMAND_SUBMIT_JOB_EPOCH,
                                     args, args_size,

=== modified file 'libgearman/protocol/submit.h'
--- libgearman/protocol/submit.h	2012-05-13 23:19:56 +0000
+++ libgearman/protocol/submit.h	2012-09-20 02:21:22 +0000
@@ -41,17 +41,17 @@
 namespace libgearman {
 namespace protocol {
 
-gearman_return_t submit(gearman_task_st&,
+gearman_return_t submit(Task&,
                         const gearman_command_t command,
                         const gearman_string_t &function,
                         const gearman_string_t &workload);
 
-gearman_return_t submit_background(gearman_task_st&,
+gearman_return_t submit_background(Task&,
                                    const gearman_command_t command,
                                    const gearman_string_t &function,
                                    const gearman_string_t &workload);
 
-gearman_return_t submit_epoch(gearman_task_st&,
+gearman_return_t submit_epoch(Task&,
                               const gearman_string_t &function,
                               const gearman_string_t &workload,
                               time_t when);

=== modified file 'libgearman/run.cc'
--- libgearman/run.cc	2012-08-02 05:44:19 +0000
+++ libgearman/run.cc	2012-09-20 02:21:22 +0000
@@ -45,13 +45,13 @@
 #include <cstdlib>
 #include <cstring>
 
-gearman_return_t _client_run_task(gearman_task_st *task)
+gearman_return_t _client_run_task(Task *task)
 {
   // This should not be possible
   assert_msg(task->client, "Programmer error, somehow an invalid task was specified");
   if (task->client == NULL)
   {
-    return gearman_universal_set_error(task->client->universal, GEARMAN_INVALID_ARGUMENT, GEARMAN_AT,
+    return gearman_universal_set_error(task->client->impl()->universal, GEARMAN_INVALID_ARGUMENT, GEARMAN_AT,
                                        "Programmer error, somehow an invalid task was specified");
   }
 
@@ -59,14 +59,14 @@
   {
   case GEARMAN_TASK_STATE_NEW:
     
-    if (task->client->universal.con_list == NULL)
+    if (task->client->impl()->universal.con_list == NULL)
     {
-      task->client->new_tasks--;
-      task->client->running_tasks--;
-      return gearman_universal_set_error(task->client->universal, GEARMAN_NO_SERVERS, GEARMAN_AT, "no servers added");
+      task->client->impl()->new_tasks--;
+      task->client->impl()->running_tasks--;
+      return gearman_universal_set_error(task->client->impl()->universal, GEARMAN_NO_SERVERS, GEARMAN_AT, "no servers added");
     }
 
-    for (task->con= task->client->universal.con_list; task->con;
+    for (task->con= task->client->impl()->universal.con_list; task->con;
          task->con= task->con->next)
     {
       if (task->con->send_state == GEARMAN_CON_SEND_STATE_NONE)
@@ -77,11 +77,11 @@
 
     if (task->con == NULL)
     {
-      task->client->options.no_new= true;
-      return gearman_gerror(task->client->universal, GEARMAN_IO_WAIT);
+      task->client->impl()->options.no_new= true;
+      return gearman_gerror(task->client->impl()->universal, GEARMAN_IO_WAIT);
     }
 
-    task->client->new_tasks--;
+    task->client->impl()->new_tasks--;
 
     if (task->send.command != GEARMAN_COMMAND_GET_STATUS)
     {
@@ -93,7 +93,7 @@
     while (1)
     {
       assert(task->con);
-      gearman_return_t ret= task->con->send_packet(task->send, task->client->new_tasks == 0 ? true : false);
+      gearman_return_t ret= task->con->send_packet(task->send, task->client->impl()->new_tasks == 0 ? true : false);
 
       if (gearman_success(ret))
       {
@@ -133,12 +133,12 @@
           if (ret == GEARMAN_COULD_NOT_CONNECT) // If no connection is found, we will let the user try again
           {
             task->state= GEARMAN_TASK_STATE_NEW;
-            task->client->new_tasks++;
+            task->client->impl()->new_tasks++;
           }
           else
           {
             task->state= GEARMAN_TASK_STATE_FAIL;
-            task->client->running_tasks--;
+            task->client->impl()->running_tasks--;
           }
           return ret;
         }
@@ -155,13 +155,13 @@
     {
       if (not task->func.workload_fn)
       {
-        gearman_error(task->client->universal, GEARMAN_NEED_WORKLOAD_FN,
+        gearman_error(task->client->impl()->universal, GEARMAN_NEED_WORKLOAD_FN,
                       "workload size > 0, but no data pointer or workload_fn was given");
         return GEARMAN_NEED_WORKLOAD_FN;
       }
 
   case GEARMAN_TASK_STATE_WORKLOAD:
-      gearman_return_t ret= task->func.workload_fn(task);
+      gearman_return_t ret= task->func.workload_fn(task->shell());
       if (gearman_failed(ret))
       {
         task->state= GEARMAN_TASK_STATE_WORKLOAD;
@@ -169,7 +169,7 @@
       }
     }
 
-    task->client->options.no_new= false;
+    task->client->impl()->options.no_new= false;
     task->state= GEARMAN_TASK_STATE_WORK;
     task->con->set_events(POLLIN);
     return GEARMAN_SUCCESS;
@@ -185,7 +185,7 @@
   case GEARMAN_TASK_STATE_CREATED:
       if (task->func.created_fn)
       {
-        gearman_return_t ret= task->func.created_fn(task);
+        gearman_return_t ret= task->func.created_fn(task->shell());
         if (gearman_failed(ret))
         {
           task->state= GEARMAN_TASK_STATE_CREATED;
@@ -210,7 +210,7 @@
   case GEARMAN_TASK_STATE_DATA:
       if (task->func.data_fn)
       {
-        gearman_return_t ret= task->func.data_fn(task);
+        gearman_return_t ret= task->func.data_fn(task->shell());
         if (gearman_failed(ret))
         {
           task->state= GEARMAN_TASK_STATE_DATA;
@@ -223,7 +223,7 @@
   case GEARMAN_TASK_STATE_WARNING:
       if (task->func.warning_fn)
       {
-        gearman_return_t ret= task->func.warning_fn(task);
+        gearman_return_t ret= task->func.warning_fn(task->shell());
         if (gearman_failed(ret))
         {
           task->state= GEARMAN_TASK_STATE_WARNING;
@@ -311,7 +311,7 @@
   case GEARMAN_TASK_STATE_STATUS:
       if (task->func.status_fn)
       {
-        gearman_return_t ret= task->func.status_fn(task);
+        gearman_return_t ret= task->func.status_fn(task->shell());
         if (gearman_failed(ret))
         {
           task->state= GEARMAN_TASK_STATE_STATUS;
@@ -338,7 +338,7 @@
   case GEARMAN_TASK_STATE_COMPLETE:
       if (task->func.complete_fn)
       {
-        gearman_return_t ret= task->func.complete_fn(task);
+        gearman_return_t ret= task->func.complete_fn(task->shell());
         if (gearman_failed(ret))
         {
           task->state= GEARMAN_TASK_STATE_COMPLETE;
@@ -353,7 +353,7 @@
   case GEARMAN_TASK_STATE_EXCEPTION:
       if (task->func.exception_fn)
       {
-        gearman_return_t ret= task->func.exception_fn(task);
+        gearman_return_t ret= task->func.exception_fn(task->shell());
         if (gearman_failed(ret))
         {
           task->state= GEARMAN_TASK_STATE_EXCEPTION;
@@ -374,7 +374,7 @@
   case GEARMAN_TASK_STATE_FAIL:
       if (task->func.fail_fn)
       {
-        gearman_return_t ret= task->func.fail_fn(task);
+        gearman_return_t ret= task->func.fail_fn(task->shell());
         if (gearman_failed(ret))
         {
           task->state= GEARMAN_TASK_STATE_FAIL;
@@ -392,12 +392,12 @@
     break;
   }
 
-  task->client->running_tasks--;
+  task->client->impl()->running_tasks--;
   task->state= GEARMAN_TASK_STATE_FINISHED;
 
-  if (task->client->options.free_tasks and task->type == GEARMAN_TASK_KIND_ADD_TASK)
+  if (task->client->impl()->options.free_tasks and task->type == GEARMAN_TASK_KIND_ADD_TASK)
   {
-    gearman_task_free(task);
+    gearman_task_free(task->shell());
   }
 
   return GEARMAN_SUCCESS;

=== modified file 'libgearman/run.hpp'
--- libgearman/run.hpp	2012-03-12 01:44:08 +0000
+++ libgearman/run.hpp	2012-09-20 02:21:22 +0000
@@ -38,4 +38,4 @@
 
 #pragma once
 
-gearman_return_t _client_run_task(gearman_task_st *task);
+gearman_return_t _client_run_task(Task *task);

=== modified file 'libgearman/task.cc'
--- libgearman/task.cc	2012-08-02 05:44:19 +0000
+++ libgearman/task.cc	2012-09-20 02:21:22 +0000
@@ -54,418 +54,367 @@
  * Public Definitions
  */
 
-#define TASK_MAGIC 134
-#define TASK_ANTI_MAGIC 157
-
-gearman_task_st *gearman_task_internal_create(gearman_client_st *client, gearman_task_st *task)
+gearman_task_st *gearman_task_internal_create(gearman_client_st& client, gearman_task_st *task_shell)
 {
-  assert(client);
+  Task* task= new (std::nothrow) Task(client, task_shell);
   if (task)
   {
-    task->options.allocated= false;
-  }
-  else
-  {
-    task= new (std::nothrow) gearman_task_st;
-    if (task == NULL)
-    {
-      gearman_perror(client->universal, "gearman_task_st new");
-      return NULL;
-    }
-
-    task->options.allocated= true;
-  }
-  task->options.is_initialized= true;
-
-  task->options.send_in_use= false;
-  task->options.is_known= false;
-  task->options.is_running= false;
-  task->options.was_reduced= false;
-  task->options.is_paused= false;
-
-  task->type= GEARMAN_TASK_KIND_ADD_TASK;
-
-  task->state= GEARMAN_TASK_STATE_NEW;
-  task->magic_= TASK_MAGIC;
-  task->created_id= 0;
-  task->numerator= 0;
-  task->denominator= 0;
-  task->client_count= 0;
-  task->client= client;
-
-  task->func= client->actions;
-  task->result_rc= GEARMAN_UNKNOWN_STATE;
-
-  // Add the task to the client
-  {
-    if (client->task_list)
-    {
-      client->task_list->prev= task;
-    }
-    task->next= client->task_list;
-    task->prev= NULL;
-    client->task_list= task;
-    client->task_count++;
-  }
-
-  task->context= NULL;
-  task->con= NULL;
-  task->recv= NULL;
-  task->result_ptr= NULL;
-  task->job_handle[0]= 0;
-  task->unique_length= 0;
-  task->unique[0]= 0;
-
-  return task;
-}
-
-
-void gearman_task_free(gearman_task_st *task)
-{
-  if (task == NULL)
-  {
-    return;
-  }
-
-  if (task->options.is_initialized == false)
-  {
-    return;
-  }
-
-  assert(task->magic_ != TASK_ANTI_MAGIC);
-  assert(task->magic_ == TASK_MAGIC);
-  task->magic_= TASK_ANTI_MAGIC;
-
-  gearman_task_free_result(task);
-
-  if (task->client)
-  {
-    if (task->options.send_in_use)
-    {
-      gearman_packet_free(&(task->send));
-    }
-
-    if (task->type != GEARMAN_TASK_KIND_DO  and task->context and  task->client->task_context_free_fn)
-    {
-      task->client->task_context_free_fn(task, static_cast<void *>(task->context));
-    }
-
-    if (task->client->task_list == task)
-    {
-      task->client->task_list= task->next;
-    }
-
-    if (task->prev)
-    {
-      task->prev->next= task->next;
-    }
-
-    if (task->next)
-    {
-      task->next->prev= task->prev;
-    }
-
-    task->client->task_count--;
-
-    // If the task we are removing is a current task, remove it from the client
-    // structures.
-    if (task->client->task == task)
-    {
-      task->client->task= NULL;
-    }
-    task->client= NULL;
-  }
-  task->job_handle[0]= 0;
-
-  task->options.is_initialized= false;
-  if (task->options.allocated)
-  {
-    delete task;
-  }
-}
-
-void gearman_task_free_result(gearman_task_st *task)
-{
-  assert(task);
-  delete task->result_ptr;
-  task->result_ptr= NULL;
-}
-
-bool gearman_task_is_active(const gearman_task_st *self)
-{
-  assert(self);
-  switch (self->state)
-  {
-  case GEARMAN_TASK_STATE_NEW:
-  case GEARMAN_TASK_STATE_SUBMIT:
-  case GEARMAN_TASK_STATE_WORKLOAD:
-  case GEARMAN_TASK_STATE_WORK:
-  case GEARMAN_TASK_STATE_CREATED:
-  case GEARMAN_TASK_STATE_DATA:
-  case GEARMAN_TASK_STATE_WARNING:
-  case GEARMAN_TASK_STATE_STATUS:
-    return true;
-
-  case GEARMAN_TASK_STATE_COMPLETE:
-  case GEARMAN_TASK_STATE_EXCEPTION:
-  case GEARMAN_TASK_STATE_FAIL:
-  case GEARMAN_TASK_STATE_FINISHED:
-    break;
-  }
-
-  return false;
-}
-
-const char *gearman_task_strstate(const gearman_task_st *self)
-{
-  if (self == NULL)
-  {
-    return NULL;
-  }
-
-  switch (self->state)
-  {
-  case GEARMAN_TASK_STATE_NEW: return "GEARMAN_TASK_STATE_NEW";
-  case GEARMAN_TASK_STATE_SUBMIT: return "GEARMAN_TASK_STATE_SUBMIT";
-  case GEARMAN_TASK_STATE_WORKLOAD: return "GEARMAN_TASK_STATE_WORKLOAD";
-  case GEARMAN_TASK_STATE_WORK: return "GEARMAN_TASK_STATE_WORK";
-  case GEARMAN_TASK_STATE_CREATED: return "GEARMAN_TASK_STATE_CREATED";
-  case GEARMAN_TASK_STATE_DATA: return "GEARMAN_TASK_STATE_DATA";
-  case GEARMAN_TASK_STATE_WARNING: return "GEARMAN_TASK_STATE_WARNING";
-  case GEARMAN_TASK_STATE_STATUS: return "GEARMAN_TASK_STATE_STATUS";
-  case GEARMAN_TASK_STATE_COMPLETE: return "GEARMAN_TASK_STATE_COMPLETE";
-  case GEARMAN_TASK_STATE_EXCEPTION: return "GEARMAN_TASK_STATE_EXCEPTION";
-  case GEARMAN_TASK_STATE_FAIL: return "GEARMAN_TASK_STATE_FAIL";
-  case GEARMAN_TASK_STATE_FINISHED: return "GEARMAN_TASK_STATE_FINISHED";
-  }
-
-  return "";
-}
-
-void gearman_task_clear_fn(gearman_task_st *task)
-{
-  if (task == NULL)
-  {
-    return;
-  }
-
-  task->func= gearman_actions_default();
-}
-
-void *gearman_task_context(const gearman_task_st *task)
-{
-  if (task == NULL)
-  {
-    return NULL;
-  }
-
-  return const_cast<void *>(task->context);
-}
-
-void gearman_task_set_context(gearman_task_st *task, void *context)
-{
-  if (task == NULL)
-  {
-    return;
-  }
-
-  task->context= context;
-}
-
-const char *gearman_task_function_name(const gearman_task_st *task)
-{
-  if (task == NULL)
-  {
-    return 0;
-  }
-
-  return task->send.arg[0];
-}
-
-const char *gearman_task_unique(const gearman_task_st *task)
-{
-  if (task == NULL)
-  {
-    return 0;
-  }
-
-  return task->unique;
-}
-
-const char *gearman_task_job_handle(const gearman_task_st *task)
-{
-  if (task == NULL)
-  {
-    return 0;
-  }
-
-  return task->job_handle;
-}
-
-bool gearman_task_is_known(const gearman_task_st *task)
-{
-  if (task == NULL)
-  {
-    return false;
-  }
-
-  return task->options.is_known;
-}
-
-bool gearman_task_is_running(const gearman_task_st *task)
-{
-  if (task == NULL)
-  {
-    return false;
-  }
-
-  return task->options.is_running;
-}
-
-uint32_t gearman_task_numerator(const gearman_task_st *task)
-{
-  if (task == NULL)
-  {
-    return 0;
-  }
-
-  return task->numerator;
-}
-
-uint32_t gearman_task_denominator(const gearman_task_st *task)
-{
-  if (task == NULL)
-  {
-    return 0;
-  }
-
-  return task->denominator;