Style cleanup

[m6w6/libmemcached] / libmemcached / get.cc

diff --git a/libmemcached/get.cc b/libmemcached/get.cc
index fa76adae7b3de6e9cc071cf6a2f26da06ab71b0d..86f136707e0d3a9ebb92d8c63e33b167e9336a8d 100644 (file)
--- a/libmemcached/get.cc
+++ b/libmemcached/get.cc
@@ -2,7 +2,7 @@
  * 
  *  Libmemcached library
  *
- *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ *  Copyright (C) 2011-2012 Data Differential, http://datadifferential.com/
  *  Copyright (C) 2006-2009 Brian Aker All rights reserved.
  *
  *  Redistribution and use in source and binary forms, with or without
@@ -111,24 +111,28 @@ char *memcached_get_by_key(memcached_st *ptr,
 
   /* This is for historical reasons */
   if (*error == MEMCACHED_END)
+  {
     *error= MEMCACHED_NOTFOUND;
+  }
 
   if (value == NULL)
   {
-    if (ptr->get_key_failure && *error == MEMCACHED_NOTFOUND)
+    if (ptr->get_key_failure and *error == MEMCACHED_NOTFOUND)
     {
       memcached_result_reset(&ptr->result);
       memcached_return_t rc= ptr->get_key_failure(ptr, key, key_length, &ptr->result);
 
       /* On all failure drop to returning NULL */
-      if (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED)
+      if (rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED)
       {
         if (rc == MEMCACHED_BUFFERED)
         {
           uint64_t latch; /* We use latch to track the state of the original socket */
           latch= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS);
           if (latch == 0)
+          {
             memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
+          }
 
           rc= memcached_set(ptr, key, key_length,
                             (memcached_result_value(&ptr->result)),
@@ -136,7 +140,7 @@ char *memcached_get_by_key(memcached_st *ptr,
                             0,
                             (memcached_result_flags(&ptr->result)));
 
-          if (rc == MEMCACHED_BUFFERED && latch == 0)
+          if (rc == MEMCACHED_BUFFERED and latch == 0)
           {
             memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0);
           }
@@ -150,7 +154,7 @@ char *memcached_get_by_key(memcached_st *ptr,
                             (memcached_result_flags(&ptr->result)));
         }
 
-        if (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED)
+        if (rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED)
         {
           *error= rc;
           *value_length= memcached_result_length(&ptr->result);
@@ -164,17 +168,6 @@ char *memcached_get_by_key(memcached_st *ptr,
     return NULL;
   }
 
-  size_t dummy_length;
-  uint32_t dummy_flags;
-  memcached_return_t dummy_error;
-
-  char *dummy_value= memcached_fetch(ptr, NULL, NULL,
-                                     &dummy_length, &dummy_flags,
-                                     &dummy_error);
-  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;
 }
 
@@ -227,17 +220,12 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
 
   if (memcached_failed(memcached_key_test(*ptr, keys, key_length, number_of_keys)))
   {
-    return memcached_set_error(*ptr, MEMCACHED_BAD_KEY_PROVIDED, MEMCACHED_AT, memcached_literal_param("A bad key value was provided"));
+    return memcached_last_error(ptr);
   }
 
   bool is_group_key_set= false;
   if (group_key and group_key_length)
   {
-    if (memcached_failed(memcached_key_test(*ptr, (const char * const *)&group_key, &group_key_length, 1)))
-    {
-      return memcached_set_error(*ptr, MEMCACHED_BAD_KEY_PROVIDED, MEMCACHED_AT, memcached_literal_param("A bad group key was provided."));
-    }
-
     master_server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length);
     is_group_key_set= true;
   }
@@ -250,8 +238,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   */
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    memcached_server_write_instance_st instance=
-      memcached_server_instance_fetch(ptr, x);
+    memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, x);
 
     if (memcached_server_response_count(instance))
     {
@@ -269,7 +256,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
     }
   }
 
-  if (ptr->flags.binary_protocol)
+  if (memcached_is_binary(ptr))
   {
     return binary_mget_by_key(ptr, master_server_key, is_group_key_set, keys,
                               key_length, number_of_keys, mget_mode);
@@ -323,7 +310,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
       }
       hosts_connected++;
 
-      if ((memcached_io_writev(instance, vector, 4, false)) == -1)
+      if ((memcached_io_writev(instance, vector, 4, false)) == false)
       {
         failures_occured_in_sending= true;
         continue;
@@ -334,7 +321,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
     }
     else
     {
-      if ((memcached_io_writev(instance, (vector + 1), 3, false)) == -1)
+      if ((memcached_io_writev(instance, (vector + 1), 3, false)) == false)
       {
         memcached_server_response_reset(instance);
         failures_occured_in_sending= true;
@@ -381,13 +368,15 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
 
   LIBMEMCACHED_MEMCACHED_MGET_END();
 
-  if (failures_occured_in_sending && success_happened)
+  if (failures_occured_in_sending and success_happened)
   {
     return MEMCACHED_SOME_ERRORS;
   }
 
   if (success_happened)
+  {
     return MEMCACHED_SUCCESS;
+  }
 
   return MEMCACHED_FAILURE; // Complete failure occurred
 }
@@ -531,7 +520,7 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
       { keys[x], key_length[x] }
     };
 
-    if (memcached_io_writev(instance, vector, 3, flush) == -1)
+    if (memcached_io_writev(instance, vector, 3, flush) == false)
     {
       memcached_server_response_reset(instance);
       rc= MEMCACHED_SOME_ERRORS;
@@ -541,7 +530,7 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
     /* We just want one pending response per server */
     memcached_server_response_reset(instance);
     memcached_server_response_increment(instance);
-    if ((x > 0 && x == ptr->io_key_prefetch) && memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS)
+    if ((x > 0 and x == ptr->io_key_prefetch) and memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS)
     {
       rc= MEMCACHED_SOME_ERRORS;
     }
@@ -597,7 +586,9 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
   uint64_t randomize_read= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ);
 
   if (randomize_read)
+  {
     start= (uint32_t)random() % (uint32_t)(ptr->number_of_replicas + 1);
+  }
 
   /* Loop for each replica */
   for (uint32_t replica= 0; replica <= ptr->number_of_replicas; ++replica)
@@ -612,8 +603,10 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
       uint32_t server= hash[x] + replica;
 
       /* In case of randomized reads */
-      if (randomize_read && ((server + start) <= (hash[x] + ptr->number_of_replicas)))
-        server += start;
+      if (randomize_read and ((server + start) <= (hash[x] + ptr->number_of_replicas)))
+      {
+        server+= start;
+      }
 
       while (server >= memcached_server_count(ptr))
       {
@@ -664,7 +657,7 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
         { keys[x], key_length[x] }
       };
 
-      if (memcached_io_writev(instance, vector, 3, true) == -1)
+      if (memcached_io_writev(instance, vector, 3, true) == false)
       {
         memcached_io_reset(instance);
         dead_servers[server]= true;
@@ -702,7 +695,7 @@ static memcached_return_t binary_mget_by_key(memcached_st *ptr,
   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)
+  if (hash == NULL or dead_servers == NULL)
   {
     libmemcached_free(ptr, hash);
     libmemcached_free(ptr, dead_servers);