Merge 1.0 tree.

ChangeLog

@@ -10,9 +10,6 @@
 * Experimental addition to queue service which will allow a queue to be stored on shutdown (--libsqlite3-store-on-shutdown).
 * Rollup of all changes in 1.0.2
 
-1.0.4
-* Added --coredump flag to gearmand
-
 1.1.3 Wed Nov  7 22:48:21 EST 2012
 * Merge with 1.0.1
 
@@ -25,6 +22,10 @@
 1.1.0 Wed Sep  5 08:33:37 PDT 2012
 * Fix for ABI compatibility issues.
 
+1.0.4
+* Added --coredump flag to gearmand
+* Removed result type enum, since the structure is never exposed to the user this was of limited use.
+
 1.0.3 Sun Feb  3 21:05:52 EST 2013
 * Allow for a longer set of retries if port is in use when the server starts up.
 * Added checking for valgrind sgcheck

libgearman-1.0/result.h

@@ -37,15 +37,6 @@
 
 #pragma once
 
-enum gearman_result_t {
-  GEARMAN_RESULT_BINARY,
-  GEARMAN_RESULT_BOOLEAN,
-  GEARMAN_RESULT_INTEGER
-};
-#ifndef __cplusplus
-typedef enum gearman_result_t gearman_result_t;
-#endif
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -59,9 +50,6 @@ extern "C" {
   GEARMAN_API
   gearman_string_t gearman_result_string(const gearman_result_st *self);
 
-  GEARMAN_LOCAL
-  gearman_string_t gearman_result_take_string(gearman_result_st *self);
-
   GEARMAN_API
   gearman_return_t gearman_result_store_string(gearman_result_st *self, gearman_string_t arg);
 

libgearman/include.am

@@ -91,6 +91,13 @@ libgearman_libgearman_vector_la_LIBADD= @DL_LIB@
 libgearman_libgearman_vector_la_SOURCES= libgearman/vector.cc
 libgearman_libgearman_vector_la_SOURCES+= libgearman/backtrace.cc
 
+noinst_LTLIBRARIES+= libgearman/libgearman-result.la
+libgearman_libgearman_result_la_CXXFLAGS= -DBUILDING_LIBGEARMAN
+libgearman_libgearman_result_la_LIBADD= @DL_LIB@
+libgearman_libgearman_result_la_SOURCES= libgearman/vector.cc
+libgearman_libgearman_result_la_SOURCES+= libgearman/result.cc
+libgearman_libgearman_result_la_SOURCES+= libgearman/backtrace.cc
+
 libgearman_libgearman_la_LIBADD=
 libgearman_libgearman_la_SOURCES=
 libgearman_libgearman_la_CXXFLAGS=

libgearman/result.cc

@@ -36,10 +36,13 @@
  */
 
 #include "gear_config.h"
-#include <libgearman/common.h>
 
+#include "libgearman/result.hpp"
 #include "libgearman/assert.hpp"
 
+#include "libgearman-1.0/visibility.h"
+#include "libgearman-1.0/result.h"
+
 #include <cstdlib>
 #include <limits>
 #include <memory>
@@ -47,48 +50,94 @@
 #include <libgearman/result.hpp>
 
 gearman_result_st::gearman_result_st() :
-  _is_null(true),
-  type(GEARMAN_RESULT_BOOLEAN)
+  type(GEARMAN_RESULT_NULL)
 {
-  value.boolean= false;
+  value._boolean= false;
 }
 
-gearman_result_st::gearman_result_st(size_t initial_size) :
-  _is_null(true),
-  type(GEARMAN_RESULT_BINARY),
-  value(initial_size)
+gearman_result_st::gearman_result_st(size_t reserve_size_) :
+  type(GEARMAN_RESULT_NULL),
+  value(reserve_size_)
 {
 }
 
 bool gearman_result_is_null(const gearman_result_st *self)
 {
-  return self->is_null();
+  assert(self);
+  if (self)
+  {
+    return self->is_null();
+  }
+
+  return true;
 }
 
-gearman_result_st::~gearman_result_st()
+size_t gearman_result_st::size() const
 {
-  if (type == GEARMAN_RESULT_BINARY)
+  switch (type)
   {
-    assert_msg(gearman_is_initialized(&value.string), "Somehow we have a GEARMAN_RESULT_BINARY, but no valid string");
-    gearman_string_free(&value.string);
+  case GEARMAN_RESULT_BINARY:
+    return value.string.size();
+
+  case GEARMAN_RESULT_BOOLEAN:
+    return 1;
+
+  case GEARMAN_RESULT_INTEGER:
+    return sizeof(int64_t);
+
+  case GEARMAN_RESULT_NULL:
+    return 0;
   }
+
+  return 0;
+}
+
+int64_t gearman_result_st::integer() const
+{
+  switch (type)
+  {
+  case GEARMAN_RESULT_BINARY:
+    return atoll(value.string.value());
+
+  case GEARMAN_RESULT_BOOLEAN:
+    return value._boolean;
+
+  case GEARMAN_RESULT_INTEGER:
+    return value._integer;
+
+  case GEARMAN_RESULT_NULL:
+    return 0;
+  }
+
+  return 0;
 }
 
 int64_t gearman_result_integer(const gearman_result_st *self)
 {
+  assert(self);
   if (self)
   {
-    switch (self->type)
-    {
-    case GEARMAN_RESULT_BINARY:
-      return atoll(gearman_string_value(&self->value.string));
+    return self->integer();
+  }
 
-    case GEARMAN_RESULT_BOOLEAN:
-      return self->value.boolean;
+  return 0;
+}
 
-    case GEARMAN_RESULT_INTEGER:
-      return self->value.integer;
-    }
+bool gearman_result_st::boolean() const
+{
+  switch (type)
+  {
+  case GEARMAN_RESULT_BINARY:
+    return value.string.size();
+
+  case GEARMAN_RESULT_BOOLEAN:
+    return value._boolean;
+
+  case GEARMAN_RESULT_INTEGER:
+    return value._integer ? true : false;
+
+  case GEARMAN_RESULT_NULL:
+    return false;
   }
 
   return false;
@@ -98,17 +147,7 @@ bool gearman_result_boolean(const gearman_result_st *self)
 {
   if (self)
   {
-    switch (self->type)
-    {
-    case GEARMAN_RESULT_BINARY:
-      return gearman_string_length(&self->value.string);
-
-    case GEARMAN_RESULT_BOOLEAN:
-      return self->value.boolean;
-
-    case GEARMAN_RESULT_INTEGER:
-      return self->value.integer ? true : false;
-    }
+    return self->boolean();
   }
 
   return false;
@@ -152,8 +191,7 @@ gearman_string_t gearman_result_take_string(gearman_result_st *self)
   if (self->type == GEARMAN_RESULT_BINARY and gearman_result_size(self))
   {
     gearman_string_t ret_string= gearman_string_take_string(&self->value.string);
-    self->type= GEARMAN_RESULT_BOOLEAN; // Set to default type
-    self->_is_null= true;
+    self->type= GEARMAN_RESULT_NULL; // Set to NULL
 
     return ret_string;
   }
@@ -164,42 +202,96 @@ gearman_string_t gearman_result_take_string(gearman_result_st *self)
 
 gearman_return_t gearman_result_store_string(gearman_result_st *self, gearman_string_t arg)
 {
-  return gearman_result_store_value(self, gearman_string_param(arg));
+  assert(self);
+  if (self)
+  {
+    if (self->store(gearman_string_param(arg)) == false)
+    {
+      return GEARMAN_MEMORY_ALLOCATION_FAILURE;
+    }
+
+    return GEARMAN_SUCCESS;
+  }
+
+  return GEARMAN_INVALID_ARGUMENT;
+}
+
+bool gearman_result_st::append(const char* arg, const size_t arg_length)
+{
+  if (type != GEARMAN_RESULT_BINARY)
+  {
+    clear();
+    type= GEARMAN_RESULT_BINARY;
+  }
+
+  if (value.string.append(arg, arg_length) == false)
+  {
+    type= GEARMAN_RESULT_NULL;
+    return false;
+  }
+
+  return true;
 }
 
-gearman_return_t gearman_result_store_value(gearman_result_st *self, const void *value, size_t size)
+bool gearman_result_st::store(const char* arg, const size_t arg_length)
 {
-  if (self == NULL)
+  value.string.clear();
+  if (gearman_string_append(&value.string, arg, arg_length) == false)
   {
-    return GEARMAN_INVALID_ARGUMENT;
+    type= GEARMAN_RESULT_NULL;
+    return false;
   }
 
-  self->value.string.clear();
-  if (value)
+  type= GEARMAN_RESULT_BINARY;
+
+  return true;
+}
+
+gearman_return_t gearman_result_store_value(gearman_result_st *self, const void *value, size_t size)
+{
+  if (self)
   {
-    if (gearman_string_append(&self->value.string, static_cast<const char *>(value), size) == false)
+    if (self->type != GEARMAN_RESULT_BINARY)
+    {
+      self->clear();
+    }
+
+    if (self->store((const char*)value, size) == false) // If append should fail, we default to NULL
     {
+      self->type= GEARMAN_RESULT_NULL;
       return GEARMAN_MEMORY_ALLOCATION_FAILURE;
     }
+    self->type= GEARMAN_RESULT_BINARY;
+
+    return GEARMAN_SUCCESS;
   }
 
-  self->_is_null= false;
-  self->type= GEARMAN_RESULT_BINARY;
+  return GEARMAN_INVALID_ARGUMENT;
+}
+
+void gearman_result_st::integer(int64_t arg_)
+{
+  if (type != GEARMAN_RESULT_INTEGER)
+  {
+    clear();
+    type= GEARMAN_RESULT_INTEGER;
+  }
 
-  return GEARMAN_SUCCESS;
+  value._integer= arg_;
 }
 
-void gearman_result_store_integer(gearman_result_st *self, int64_t value)
+void gearman_result_store_integer(gearman_result_st *self, int64_t arg_)
 {
   if (self)
   {
-    if (self->type == GEARMAN_RESULT_BINARY)
-    {
-      self->value.string.clear();
-    }
+    self->integer(arg_);
+  }
+}
 
-    self->type= GEARMAN_RESULT_INTEGER;
-    self->value.integer= value;
-    self->_is_null= false;
+void gearman_result_store_boolean(gearman_result_st *self, const bool arg_)
+{
+  if (self)
+  {
+    self->boolean(arg_);
   }
 }

libgearman/result.hpp

@@ -39,26 +39,37 @@
 #pragma once
 
 #include "libgearman/assert.hpp"
+#include "libgearman/vector.hpp"
+#include "libgearman-1.0/return.h"
+
+#include <cstddef>
+#include <cstdlib>
 #include <cstring>
 
+enum gearman_result_t {
+  GEARMAN_RESULT_BINARY,
+  GEARMAN_RESULT_BOOLEAN,
+  GEARMAN_RESULT_INTEGER,
+  GEARMAN_RESULT_NULL
+};
+
 struct gearman_result_st
 {
-  bool _is_null;
   enum gearman_result_t type;
 
   struct Value {
-    bool boolean;
-    int64_t integer;
+    bool _boolean;
+    int64_t _integer;
     gearman_vector_st string;
 
     Value() :
-      boolean(false),
-      integer(0)
+      _boolean(false),
+      _integer(0)
     { }
 
     Value(size_t initial_size) :
-      boolean(false),
-      integer(0),
+      _boolean(false),
+      _integer(0),
       string(initial_size)
     { }
 
@@ -66,51 +77,45 @@ struct gearman_result_st
 
   gearman_result_st();
 
-  explicit gearman_result_st(size_t initial_size);
+  explicit gearman_result_st(size_t);
 
   bool is_null() const
   {
-    return _is_null;
+    return type == GEARMAN_RESULT_NULL ? true : false;
   }
 
-  void reserve(size_t reserve_size)
+  void clear()
   {
-    if (type == GEARMAN_RESULT_BINARY)
-    {
-      gearman_string_reserve(&value.string, reserve_size);
-    }
-    else
-    {
-      type= GEARMAN_RESULT_BINARY;
-      gearman_string_create(&value.string, reserve_size);
-      _is_null= true;
-    }
+    value.string.clear();
+    value._integer= 0;
+    value._boolean= false;
+    type= GEARMAN_RESULT_NULL;
   }
 
-  void clear()
-  {
-    switch (type)
-    {
-    case GEARMAN_RESULT_BINARY:
-      value.string.clear();
-      break;
+  bool store(const char*, const size_t);
+  bool append(const char*, const size_t);
 
-    case GEARMAN_RESULT_INTEGER:
-      value.integer= 0;
-      break;
+  size_t size() const;
 
-    case GEARMAN_RESULT_BOOLEAN:
-      value.boolean= false;
-      break;
-    }
+  size_t capacity() const
+  {
+    return value.string.capacity();
+  }
+
+  void resize(size_t arg_)
+  {
+    return value.string.resize(arg_);
+  }
 
-    _is_null= true;
+  void reserve(size_t arg_)
+  {
+    return value.string.reserve(arg_);
   }
 
   gearman_vector_st *mutable_string()
   {
-    value.integer= 0;
-    value.boolean= false;
+    value._integer= 0;
+    value._boolean= false;
     type= GEARMAN_RESULT_BINARY;
 
     return &value.string;
@@ -126,19 +131,31 @@ struct gearman_result_st
     return NULL;
   }
 
-  int64_t integer()
+  void boolean(bool arg_)
   {
-    if (type == GEARMAN_RESULT_INTEGER)
+    if (type != GEARMAN_RESULT_BOOLEAN)
     {
-      return value.integer;
+      clear();
+      type= GEARMAN_RESULT_BOOLEAN;
     }
 
-    return 0;
+    value._boolean= arg_;
   }
 
-  ~gearman_result_st();
+  bool boolean() const;
+
+  int64_t integer() const;
+  void integer(int64_t);
+
+  ~gearman_result_st()
+  {
+    gearman_string_free(&value.string);
+  }
 
 private:
   gearman_result_st( const gearman_result_st& );
   const gearman_result_st& operator=( const gearman_result_st& );
 };
+
+
+gearman_string_t gearman_result_take_string(gearman_result_st *self);

libgearman/vector.cc

@@ -236,6 +236,17 @@ void gearman_string_clear(gearman_vector_st *string)
   string->clear();
 }
 
+bool gearman_vector_st::store(const char* arg_, const size_t arg_length_)
+{
+  clear();
+  return append(arg_, arg_length_);
+}
+
+bool gearman_vector_st::append(const char* arg_, const size_t arg_length_)
+{
+  return gearman_string_append(this, arg_, arg_length_);
+}
+
 gearman_vector_st::~gearman_vector_st()
 {
   if (string)

libgearman/vector.hpp

@@ -78,7 +78,6 @@ struct gearman_vector_st {
   void resize(size_t);
   void reserve(size_t);
 
-
   void clear()
   {
     end= string;
@@ -88,6 +87,11 @@ struct gearman_vector_st {
     }
   }
 
+  const char* value() const
+  {
+    return string;
+  }
+
   size_t capacity() const
   {
     // We tell a white lie about size since we always keep things null
@@ -100,6 +104,9 @@ struct gearman_vector_st {
     return current_size;
   }
 
+  bool store(const char*, const size_t);
+  bool append(const char* arg_, const size_t arg_length_);
+
   size_t size() const;
 
   void init();

tests/cycle.cc

@@ -122,8 +122,8 @@ static test_return_t server_startup_conflict_TEST(void*)
   cycle_context_st *context= (cycle_context_st*)object;
 
   in_port_t bind_port= libtest::get_free_port();
-  ASSERT_EQ(true, server_startup(context->servers, "gearmand", bind_port, 0, NULL, false));
-  ASSERT_EQ(false, server_startup(context->servers, "gearmand", bind_port, 0, NULL, false));
+  ASSERT_EQ(true, server_startup(context->servers, "gearmand", bind_port, NULL, false));
+  ASSERT_EQ(false, server_startup(context->servers, "gearmand", bind_port, NULL, false));
 #endif
 
   return TEST_SUCCESS;

tests/drizzle_test.cc

@@ -58,7 +58,7 @@ static test_return_t collection_init(void *object)
 
 #if defined(HAVE_DRIZZLED_BINARY) && HAVE_DRIZZLED_BINARY
   drizzled_port= libtest::get_free_port();
-  if (server_startup(test->_servers, "drizzled", drizzled_port, 0, NULL) == false)
+  if (server_startup(test->_servers, "drizzled", drizzled_port, NULL) == false)
   {
     return TEST_SKIPPED;
   }

tests/include.am

@@ -63,6 +63,23 @@ test-vector: tests/vector
 valgrind-vector: tests/vector
 	@$(VALGRIND_COMMAND) tests/vector
 
+# Vector tests
+tests_result_SOURCES=
+tests_result_LDADD=
+
+tests_result_SOURCES+= tests/result.cc
+tests_result_LDADD+= libtest/libtest.la
+tests_result_LDADD+= libgearman/libgearman-result.la
+check_PROGRAMS+= tests/result
+noinst_PROGRAMS+= tests/result
+
+test-result: tests/result
+	@tests/result
+
+valgrind-result: tests/result
+	@$(VALGRIND_COMMAND) tests/result
+
+
 EXTRA_tests_cli_DEPENDENCIES=
 tests_cli_SOURCES=
 tests_cli_LDADD=