More language shift.

libgearman/client.cc

@@ -319,7 +319,7 @@ gearman_return_t gearman_client_add_server(gearman_client_st *client,
     return GEARMAN_INVALID_ARGUMENT;
   }
 
-  if (gearman_connection_create_args(&client->universal, NULL, host, port) == NULL)
+  if (gearman_connection_create_args(client->universal, NULL, host, port) == NULL)
   {
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;
   }

libgearman/connection.cc

@@ -147,10 +147,10 @@ gearman_connection_st *gearman_connection_create(gearman_universal_st &universal
   return connection;
 }
 
-gearman_connection_st *gearman_connection_create_args(gearman_universal_st *gearman, gearman_connection_st *connection,
+gearman_connection_st *gearman_connection_create_args(gearman_universal_st& universal, gearman_connection_st *connection,
                                                       const char *host, in_port_t port)
 {
-  connection= gearman_connection_create(*gearman, connection, NULL);
+  connection= gearman_connection_create(universal, connection, NULL);
   if (not connection)
     return NULL;
 
@@ -159,10 +159,10 @@ gearman_connection_st *gearman_connection_create_args(gearman_universal_st *gear
   return connection;
 }
 
-gearman_connection_st *gearman_connection_clone(gearman_universal_st *gearman, gearman_connection_st *connection,
+gearman_connection_st *gearman_connection_clone(gearman_universal_st& universal, gearman_connection_st *connection,
                                                 const gearman_connection_st *from)
 {
-  connection= gearman_connection_create(*gearman, connection, NULL);
+  connection= gearman_connection_create(universal, connection, NULL);
 
   if (not from or  not connection)
     return connection;

libgearman/connection.h

@@ -86,36 +86,6 @@ enum gearman_con_universal_t {
 
 #ifdef GEARMAN_CORE
 
-/**
- * Create a connection structure with the given host and port.
- *
- * @param[in] gearman Structure previously initialized with gearman_create() or
- *  gearman_clone().
- * @param[in] connection Caller allocated structure, or NULL to allocate one.
- * @param[in] host Host or IP address to connect to.
- * @param[in] port Port to connect to.
- * @return On success, a pointer to the (possibly allocated) structure. On
- *  failure this will be NULL.
- */
-GEARMAN_INTERNAL_API
-gearman_connection_st *gearman_connection_create_args(gearman_universal_st *gearman,
-                                                      gearman_connection_st *connection,
-                                                      const char *host, in_port_t port);
-
-/**
- * Clone a connection structure.
- *
- * @param[in] gearman Structure previously initialized with gearman_create() or
- *  gearman_clone().
- * @param[in] connection Caller allocated structure, or NULL to allocate one.
- * @param[in] from Structure to use as a source to clone from.
- * @return On success, a pointer to the (possibly allocated) structure. On
- *  failure this will be NULL.
- */
-GEARMAN_INTERNAL_API
-gearman_connection_st *gearman_connection_clone(gearman_universal_st *gearman, gearman_connection_st *src,
-                                                const gearman_connection_st *from);
-
 /**
  * Free a connection structure.
  *

libgearman/connection.hpp

@@ -86,7 +86,27 @@ struct gearman_connection_st
  * failed.
  */
 
-GEARMAN_INTERNAL_API
+GEARMAN_LOCAL
 gearman_connection_st *gearman_connection_create(gearman_universal_st &universal,
                                                  gearman_connection_st *connection,
                                                  gearman_connection_options_t *options);
+
+GEARMAN_LOCAL
+gearman_connection_st *gearman_connection_clone(gearman_universal_st& universal, gearman_connection_st *src,
+                                                const gearman_connection_st *from);
+
+/**
+ * Create a connection structure with the given host and port.
+ *
+ * @param[in] gearman Structure previously initialized with gearman_create() or
+ *  gearman_clone().
+ * @param[in] connection Caller allocated structure, or NULL to allocate one.
+ * @param[in] host Host or IP address to connect to.
+ * @param[in] port Port to connect to.
+ * @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,
+                                                      gearman_connection_st *connection,
+                                                      const char *host, in_port_t port);

libgearman/packet.h

@@ -36,25 +36,8 @@
  *
  */
 
-/**
- * @file
- * @brief Packet Declarations
- */
-
 #pragma once
 
-/**
- * @addtogroup gearman_packet Packet Declarations
- * @ingroup gearman_universal
- *
- * This is a low level interface for gearman packet. This is used internally
- * internally by both client and worker interfaces (or more specifically, tasks
- * and jobs), so you probably want to look there first. This is usually used to
- * write lower level clients, workers, proxies, or your own server.
- *
- * @{
- */
-
 enum gearman_magic_t
 {
   GEARMAN_MAGIC_TEXT,
@@ -86,37 +69,3 @@ struct gearman_packet_st
   size_t arg_size[GEARMAN_MAX_COMMAND_ARGS];
   char args_buffer[GEARMAN_ARGS_BUFFER_SIZE];
 };
-
-#ifdef GEARMAN_CORE
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-typedef size_t (gearman_packet_pack_fn)(const gearman_packet_st *packet,
-                                        void *data, size_t data_size,
-                                        gearman_return_t *ret_ptr);
-typedef size_t (gearman_packet_unpack_fn)(gearman_packet_st *packet,
-                                          const void *data, size_t data_size,
-                                          gearman_return_t *ret_ptr);
-
-/**
- * Pack header.
- */
-GEARMAN_INTERNAL_API
-gearman_return_t gearman_packet_pack_header(gearman_packet_st *packet);
-
-/**
- * Unpack header.
- */
-GEARMAN_INTERNAL_API
-gearman_return_t gearman_packet_unpack_header(gearman_packet_st *packet);
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* GEARMAN_CORE */
-

libgearman/packet.hpp

@@ -112,3 +112,15 @@ GEARMAN_LOCAL
 gearman_return_t gearman_packet_create_arg(gearman_packet_st& packet,
                                            const void *arg, size_t arg_size);
 
+
+/**
+ * Pack header.
+ */
+GEARMAN_LOCAL
+gearman_return_t gearman_packet_pack_header(gearman_packet_st *packet);
+
+/**
+ * Unpack header.
+ */
+GEARMAN_LOCAL
+gearman_return_t gearman_packet_unpack_header(gearman_packet_st *packet);

libgearman/universal.cc

@@ -74,7 +74,7 @@ void gearman_universal_clone(gearman_universal_st &destination, const gearman_un
 
   for (gearman_connection_st *con= source.con_list; con; con= con->next)
   {
-    if (gearman_connection_clone(&destination, NULL, con) == NULL)
+    if (gearman_connection_clone(destination, NULL, con) == NULL)
     {
       gearman_universal_free(destination);
       return;

libgearman/vector.hpp

@@ -72,7 +72,7 @@ gearman_return_t gearman_string_append_character(gearman_vector_st *string,
                                                      char character);
 GEARMAN_LOCAL
 gearman_return_t gearman_string_append(gearman_vector_st *string,
-                                           const char *value, size_t length);
+                                       const char *value, size_t length);
 GEARMAN_LOCAL
 void gearman_string_reset(gearman_vector_st *string);
 

libgearman/worker.cc

@@ -412,14 +412,13 @@ void gearman_worker_set_workload_free_fn(gearman_worker_st *worker,
 gearman_return_t gearman_worker_add_server(gearman_worker_st *worker,
                                            const char *host, in_port_t port)
 {
-  if (gearman_connection_create_args((&worker->universal), NULL, host, port) == NULL)
+  if (gearman_connection_create_args(worker->universal, NULL, host, port) == NULL)
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;
 
   return GEARMAN_SUCCESS;
 }
 
-gearman_return_t gearman_worker_add_servers(gearman_worker_st *worker,
-                                            const char *servers)
+gearman_return_t gearman_worker_add_servers(gearman_worker_st *worker, const char *servers)
 {
   return gearman_parse_servers(servers, _worker_add_server, worker);
 }