Remove memcached_do()

[awesomized/libmemcached] / libmemcached / get.cc

diff --git a/libmemcached/get.cc b/libmemcached/get.cc
index dcb9f0012ba7234f8ae882ae635d4b6ad4030268..c10f234171def1771630a0ed7e6557d1c3eb05e2 100644 (file)
--- a/libmemcached/get.cc
+++ b/libmemcached/get.cc
@@ -36,7 +36,6 @@
  */
 
 #include <libmemcached/common.h>
-#include <cassert>
 
 /*
   What happens if no servers exist?
@@ -69,12 +68,16 @@ char *memcached_get_by_key(memcached_st *ptr,
 {
   memcached_return_t unused;
   if (error == NULL)
+  {
     error= &unused;
+  }
 
-  unlikely (ptr->flags.use_udp)
+  if (ptr->flags.use_udp)
   {
     if (value_length) 
+    {
       *value_length= 0;
+    }
 
     *error= memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT);
     return NULL;
@@ -87,7 +90,7 @@ char *memcached_get_by_key(memcached_st *ptr,
   *error= memcached_mget_by_key_real(ptr, group_key, group_key_length,
                                      (const char * const *)&key, &key_length, 
                                      1, false);
-  assert(ptr->query_id == query_id +1);
+  assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
 
 
   if (memcached_failed(*error))
@@ -105,7 +108,7 @@ char *memcached_get_by_key(memcached_st *ptr,
 
   char *value= memcached_fetch(ptr, NULL, NULL,
                                value_length, flags, error);
-  assert(ptr->query_id == query_id +1);
+  assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
 
   /* This is for historical reasons */
   if (*error == MEMCACHED_END)
@@ -157,7 +160,7 @@ char *memcached_get_by_key(memcached_st *ptr,
         }
       }
     }
-    assert(ptr->query_id == query_id +1);
+    assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
 
     return NULL;
   }
@@ -169,9 +172,9 @@ char *memcached_get_by_key(memcached_st *ptr,
   char *dummy_value= memcached_fetch(ptr, NULL, NULL,
                                      &dummy_length, &dummy_flags,
                                      &dummy_error);
-  WATCHPOINT_ASSERT(dummy_length == 0);
-  WATCHPOINT_ASSERT(dummy_value == 0);
-  assert(ptr->query_id == query_id +1);
+  assert_msg(dummy_value == 0, "memcached_fetch() returned additional values beyond the single get it expected");
+  assert_msg(dummy_length == 0, "memcached_fetch() returned additional values beyond the single get it expected");
+  assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
 
   return value;
 }
@@ -211,7 +214,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
     return rc;
   }
 
-  unlikely (ptr->flags.use_udp)
+  if (ptr->flags.use_udp)
   {
     return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT);
   }
@@ -229,7 +232,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   }
 
   bool is_group_key_set= false;
-  if (group_key && group_key_length)
+  if (group_key and group_key_length)
   {
     if (memcached_failed(memcached_key_test(*ptr, (const char * const *)&group_key, &group_key_length, 1)))
     {
@@ -299,10 +302,10 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
 
     struct libmemcached_io_vector_st vector[]=
     {
-      { get_command_length, get_command },
-      { memcached_array_size(ptr->_namespace), memcached_array_string(ptr->_namespace) },
-      { key_length[x], keys[x] },
-      { 1, " " }
+      { get_command, get_command_length },
+      { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) },
+      { keys[x], key_length[x] },
+      { memcached_literal_param(" ") }
     };
 
 
@@ -419,7 +422,9 @@ memcached_return_t memcached_mget_execute_by_key(memcached_st *ptr,
                                                  unsigned int number_of_callbacks)
 {
   if ((ptr->flags.binary_protocol) == 0)
+  {
     return MEMCACHED_NOT_SUPPORTED;
+  }
 
   memcached_return_t rc;
   memcached_callback_st *original_callbacks= ptr->callbacks;
@@ -470,7 +475,9 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
     {
       rc= memcached_connect(instance);
       if (memcached_failed(rc))
+      {
         continue;
+      }
     }
 
     protocol_binary_request_getk request= { }; //= {.bytes= {0}};
@@ -499,9 +506,9 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
 
     struct libmemcached_io_vector_st vector[]=
     {
-      { sizeof(request.bytes), request.bytes },
-      { memcached_array_size(ptr->_namespace), memcached_array_string(ptr->_namespace) },
-      { key_length[x], keys[x] }
+      { request.bytes, sizeof(request.bytes) },
+      { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) },
+      { keys[x], key_length[x] }
     };
 
     if (memcached_io_writev(instance, vector, 3, flush) == -1)
@@ -590,16 +597,21 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
         server += start;
 
       while (server >= memcached_server_count(ptr))
+      {
         server -= memcached_server_count(ptr);
+      }
 
       if (dead_servers[server])
+      {
         continue;
+      }
 
       memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server);
 
       if (memcached_server_response_count(instance) == 0)
       {
         rc= memcached_connect(instance);
+
         if (memcached_failed(rc))
         {
           memcached_io_reset(instance);
@@ -628,9 +640,9 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
      */
       struct libmemcached_io_vector_st vector[]=
       {
-        { sizeof(request.bytes), request.bytes },
-        { memcached_array_size(ptr->_namespace), memcached_array_string(ptr->_namespace) },
-        { key_length[x], keys[x] }
+        { request.bytes, sizeof(request.bytes) },
+        { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) },
+        { keys[x], key_length[x] }
       };
 
       if (memcached_io_writev(instance, vector, 3, true) == -1)
@@ -646,7 +658,9 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
     }
 
     if (success)
+    {
       break;
+    }
   }
 
   return rc;
@@ -666,8 +680,8 @@ static memcached_return_t binary_mget_by_key(memcached_st *ptr,
                               keys, key_length, number_of_keys, mget_mode);
   }
 
-  uint32_t* hash= static_cast<uint32_t*>(libmemcached_malloc(ptr, sizeof(uint32_t) * number_of_keys));
-  bool* dead_servers= static_cast<bool*>(libmemcached_calloc(ptr, memcached_server_count(ptr), sizeof(bool)));
+  uint32_t* hash= libmemcached_xvalloc(ptr, number_of_keys, uint32_t);
+  bool* dead_servers= libmemcached_xcalloc(ptr, memcached_server_count(ptr), bool);
 
   if (hash == NULL || dead_servers == NULL)
   {