Abstraction (which will save us merge hell with 1.2).

[awesomized/libmemcached] / libmemcached / error.cc

diff --git a/libmemcached/error.cc b/libmemcached/error.cc
index f963e12446d42e2570733eea36aaae4187f1adbb..8532678088a7d6f3f9f1133a78e0036c6d8fe8cc 100644 (file)
--- a/libmemcached/error.cc
+++ b/libmemcached/error.cc
@@ -50,7 +50,7 @@ struct memcached_error_t
   char message[MAX_ERROR_LENGTH];
 };
 
-static void _set(org::libmemcached::Instance& server, memcached_st& memc)
+static void _set(org::libmemcached::Instance& server, Memcached& memc)
 {
   if (server.error_messages and server.error_messages->query_id != server.root->query_id)
   {
@@ -153,37 +153,37 @@ static void _set(memcached_st& memc, memcached_string_t *str, memcached_return_t
 
   if (str and str->size and local_errno)
   {
-    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s(%s), %.*s -> %s", 
-                               long(error->root),
+    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s), %.*s -> %s", 
+                               error->root,
                                memcached_strerror(&memc, rc), 
                                errmsg_ptr,
                                memcached_string_printf(*str), at);
   }
   else if (local_errno)
   {
-    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s(%s) -> %s", 
-                               long(error->root),
+    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s) -> %s", 
+                               error->root,
                                memcached_strerror(&memc, rc), 
                                errmsg_ptr,
                                at);
   }
   else if (rc == MEMCACHED_PARSE_ERROR and str and str->size)
   {
-    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %.*s -> %s", 
-                               long(error->root),
+    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %.*s -> %s", 
+                               error->root,
                                int(str->size), str->c_str, at);
   }
   else if (str and str->size)
   {
-    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s, %.*s -> %s", 
-                               long(error->root),
+    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s, %.*s -> %s", 
+                               error->root,
                                memcached_strerror(&memc, rc), 
                                int(str->size), str->c_str, at);
   }
   else
   {
-    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s -> %s", 
-                               long(error->root),
+    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s -> %s", 
+                               error->root,
                                memcached_strerror(&memc, rc), at);
   }
 
@@ -276,7 +276,7 @@ memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcac
 {
   assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
   assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a org::libmemcached::Instance");
-  if (memcached_fatal(rc) == false)
+  if (memcached_fatal(rc) == false and rc != MEMCACHED_CLIENT_ERROR)
   {
     return rc;
   }
@@ -295,7 +295,7 @@ memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcac
 
   memcached_string_t error_host= { hostname_port_message, size_t(size) };
 
-  assert(self.root);
+  assert_msg(self.root, "Programmer error, root was not set on instance");
   if (self.root == NULL)
   {
     return rc;
@@ -305,6 +305,7 @@ memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcac
   _set(self, (*self.root));
   assert(self.root->error_messages);
   assert(self.error_messages);
+  assert(self.error_messages->rc == self.root->error_messages->rc);
 
   return rc;
 }
@@ -317,7 +318,7 @@ memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcac
     return rc;
   }
 
-  char hostname_port[NI_MAXHOST +NI_MAXSERV + sizeof("host : ")];
+  char hostname_port[MEMCACHED_NI_MAXHOST +MEMCACHED_NI_MAXSERV + sizeof("host : ")];
   size_t size= append_host_to_string(self, hostname_port, sizeof(hostname_port));
 
   memcached_string_t error_host= { hostname_port, size};
@@ -411,6 +412,15 @@ memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int lo
   _set(*self.root, &error_host, rc, at, local_errno);
   _set(self, (*self.root));
 
+#if 0
+  if (self.root->error_messages->rc != self.error_messages->rc)
+  {
+    fprintf(stderr, "%s:%d %s != %s\n", __FILE__, __LINE__,
+            memcached_strerror(NULL, self.root->error_messages->rc),
+            memcached_strerror(NULL, self.error_messages->rc));
+  }
+#endif
+
   return rc;
 }
 
@@ -457,8 +467,9 @@ static void _error_print(const memcached_error_t *error)
   _error_print(error->next);
 }
 
-void memcached_error_print(const memcached_st *self)
+void memcached_error_print(const memcached_st *shell)
 {
+  const Memcached* self= memcached2Memcached(shell);
   if (self == NULL)
   {
     return;
@@ -507,8 +518,9 @@ const char *memcached_error(const memcached_st *memc)
   return memcached_last_error_message(memc);
 }
 
-const char *memcached_last_error_message(const memcached_st *memc)
+const char *memcached_last_error_message(const memcached_st *shell)
 {
+  const Memcached* memc= memcached2Memcached(shell);
   if (memc)
   {
     if (memc->error_messages)
@@ -544,8 +556,9 @@ bool memcached_has_current_error(org::libmemcached::Instance& server)
   return memcached_has_current_error(*(server.root));
 }
 
-memcached_return_t memcached_last_error(const memcached_st *memc)
+memcached_return_t memcached_last_error(const memcached_st *shell)
 {
+  const Memcached* memc= memcached2Memcached(shell);
   if (memc)
   {
     if (memc->error_messages)
@@ -559,8 +572,9 @@ memcached_return_t memcached_last_error(const memcached_st *memc)
   return MEMCACHED_INVALID_ARGUMENTS;
 }
 
-int memcached_last_error_errno(const memcached_st *memc)
+int memcached_last_error_errno(const memcached_st *shell)
 {
+  const Memcached* memc= memcached2Memcached(shell);
   if (memc == NULL)
   {
     return 0;