Merge in build lp

[awesomized/libmemcached] / libmemcached / memcached.hpp

diff --git a/libmemcached/memcached.hpp b/libmemcached/memcached.hpp
index 3bc1d227f934650f63fbcf9c803fb3ba20e35148..58fff4df7fcc0401f8b2c738bf32d51cf96cb5cb 100644 (file)
--- a/libmemcached/memcached.hpp
+++ b/libmemcached/memcached.hpp
@@ -117,7 +117,17 @@ public:
    */
   bool configure(const std::string &configuration)
   {
-    return (memcached_success(memcached_parse_configuration(memc, configuration.c_str(), configuration.size())));
+    memcached_st *new_memc= memcached(configuration.c_str(), configuration.size());
+
+    if (new_memc)
+    {
+      memcached_free(memc);
+      memc= new_memc;
+
+      return true;
+    }
+
+    return false;
   }
 
   /**
@@ -129,11 +139,7 @@ public:
    */
   bool addServer(const std::string &server_name, in_port_t port)
   {
-    memcached_return_t rc;
-
-    rc= memcached_server_add(memc, server_name.c_str(), port);
-
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_server_add(memc, server_name.c_str(), port));
   }
 
   /**
@@ -167,30 +173,41 @@ public:
    * @return a memcached return structure
    */
   memcached_return_t fetch(std::string &key,
-                         std::vector<char> &ret_val)
+                           std::vector<char> &ret_val,
+                           uint32_t &flags,
+                           uint64_t &cas_value)
   {
-    char ret_key[MEMCACHED_MAX_KEY];
-    size_t value_length= 0;
-    size_t key_length= 0;
     memcached_return_t rc;
-    uint32_t flags= 0;
-    char *value= memcached_fetch(memc, ret_key, &key_length,
-                                 &value_length, &flags, &rc);
-    if (value && ret_val.empty())
-    {
-      ret_val.reserve(value_length);
-      ret_val.assign(value, value + value_length);
-      key.assign(ret_key, key_length);
-      free(value);
-    }
-    else if (value)
+
+    memcached_result_st *result;
+    if ((result= memcached_fetch_result(memc, NULL, &rc)))
     {
-      free(value);
+      // Key
+      key.assign(memcached_result_key_value(result), memcached_result_key_length(result));
+
+      // Actual value, null terminated
+      ret_val.reserve(memcached_result_length(result) +1);
+      ret_val.assign(memcached_result_value(result), 
+                     memcached_result_value(result) +memcached_result_length(result));
+
+      // Misc
+      flags= memcached_result_flags(result);
+      cas_value= memcached_result_cas(result);
     }
+    memcached_result_free(result);
 
     return rc;
   }
 
+  memcached_return_t fetch(std::string &key,
+                           std::vector<char> &ret_val)
+  {
+    uint32_t flags= 0;
+    uint64_t cas_value= 0;
+
+    return fetch(key, ret_val, flags, cas_value);
+  }
+
   /**
    * Fetches an individual value from the server.
    *
@@ -214,6 +231,7 @@ public:
       free(value);
       return true;
     }
+
     return false;
   }
 
@@ -284,10 +302,9 @@ public:
      * If the std::vector of keys is empty then we cannot
      * call memcached_mget as we will get undefined behavior.
      */
-    if (! real_keys.empty())
+    if (not real_keys.empty())
     {
-      memcached_return_t rc= memcached_mget(memc, &real_keys[0], &key_len[0], real_keys.size());
-      return (rc == MEMCACHED_SUCCESS);
+      return memcached_success(memcached_mget(memc, &real_keys[0], &key_len[0], real_keys.size()));
     }
 
     return false;
@@ -333,13 +350,12 @@ public:
                 time_t expiration,
                 uint32_t flags)
   {
-    memcached_return_t rc= memcached_set_by_key(memc, master_key.c_str(),
-                                                master_key.length(),
-                                                key.c_str(), key.length(),
-                                                &value[0], value.size(),
-                                                expiration,
-                                                flags);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_set_by_key(memc, master_key.c_str(),
+                                                  master_key.length(),
+                                                  key.c_str(), key.length(),
+                                                  &value[0], value.size(),
+                                                  expiration,
+                                                  flags));
   }
 
   /**
@@ -414,9 +430,7 @@ public:
    */
   bool increment(const std::string &key, uint32_t offset, uint64_t *value)
   {
-    memcached_return_t rc= memcached_increment(memc, key.c_str(), key.length(),
-                                               offset, value);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_increment(memc, key.c_str(), key.length(), offset, value));
   }
 
   /**
@@ -431,10 +445,9 @@ public:
    */
   bool decrement(const std::string &key, uint32_t offset, uint64_t *value)
   {
-    memcached_return_t rc= memcached_decrement(memc, key.c_str(),
-                                               key.length(),
-                                               offset, value);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_decrement(memc, key.c_str(),
+                                                 key.length(),
+                                                 offset, value));
   }
 
 
@@ -448,9 +461,8 @@ public:
    */
   bool add(const std::string &key, const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_add(memc, key.c_str(), key.length(),
-                                         &value[0], value.size(), 0, 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_add(memc, key.c_str(), key.length(),
+                                           &value[0], value.size(), 0, 0));
   }
 
   /**
@@ -467,15 +479,14 @@ public:
                 const std::string &key,
                 const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_add_by_key(memc,
-                                                master_key.c_str(),
-                                                master_key.length(),
-                                                key.c_str(),
-                                                key.length(),
-                                                &value[0],
-                                                value.size(),
-                                                0, 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_add_by_key(memc,
+                                                  master_key.c_str(),
+                                                  master_key.length(),
+                                                  key.c_str(),
+                                                  key.length(),
+                                                  &value[0],
+                                                  value.size(),
+                                                  0, 0));
   }
 
   /**
@@ -488,10 +499,9 @@ public:
    */
   bool replace(const std::string &key, const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_replace(memc, key.c_str(), key.length(),
-                                             &value[0], value.size(),
-                                             0, 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_replace(memc, key.c_str(), key.length(),
+                                               &value[0], value.size(),
+                                               0, 0));
   }
 
   /**
@@ -508,15 +518,14 @@ public:
                     const std::string &key,
                     const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_replace_by_key(memc,
-                                                    master_key.c_str(),
-                                                    master_key.length(),
-                                                    key.c_str(),
-                                                    key.length(),
-                                                    &value[0],
-                                                    value.size(),
-                                                    0, 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_replace_by_key(memc,
+                                                      master_key.c_str(),
+                                                      master_key.length(),
+                                                      key.c_str(),
+                                                      key.length(),
+                                                      &value[0],
+                                                      value.size(),
+                                                      0, 0));
   }
 
   /**
@@ -528,9 +537,8 @@ public:
    */
   bool prepend(const std::string &key, const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_prepend(memc, key.c_str(), key.length(),
-                                             &value[0], value.size(), 0, 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_prepend(memc, key.c_str(), key.length(),
+                                               &value[0], value.size(), 0, 0));
   }
 
   /**
@@ -547,16 +555,15 @@ public:
                     const std::string &key,
                     const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_prepend_by_key(memc,
-                                                    master_key.c_str(),
-                                                    master_key.length(),
-                                                    key.c_str(),
-                                                    key.length(),
-                                                    &value[0],
-                                                    value.size(),
-                                                    0,
-                                                    0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_prepend_by_key(memc,
+                                                      master_key.c_str(),
+                                                      master_key.length(),
+                                                      key.c_str(),
+                                                      key.length(),
+                                                      &value[0],
+                                                      value.size(),
+                                                      0,
+                                                      0));
   }
 
   /**
@@ -568,13 +575,12 @@ public:
    */
   bool append(const std::string &key, const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_append(memc,
-                                            key.c_str(),
-                                            key.length(),
-                                            &value[0],
-                                            value.size(),
-                                            0, 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_append(memc,
+                                              key.c_str(),
+                                              key.length(),
+                                              &value[0],
+                                              value.size(),
+                                              0, 0));
   }
 
   /**
@@ -591,15 +597,14 @@ public:
                    const std::string &key,
                    const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_append_by_key(memc,
-                                                   master_key.c_str(),
-                                                   master_key.length(),
-                                                   key.c_str(),
-                                                   key.length(),
-                                                   &value[0],
-                                                   value.size(),
-                                                   0, 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_append_by_key(memc,
+                                                     master_key.c_str(),
+                                                     master_key.length(),
+                                                     key.c_str(),
+                                                     key.length(),
+                                                     &value[0],
+                                                     value.size(),
+                                                     0, 0));
   }
 
   /**
@@ -614,10 +619,9 @@ public:
            const std::vector<char> &value,
            uint64_t cas_arg)
   {
-    memcached_return_t rc= memcached_cas(memc, key.c_str(), key.length(),
-                                         &value[0], value.size(),
-                                         0, 0, cas_arg);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_cas(memc, key.c_str(), key.length(),
+                                           &value[0], value.size(),
+                                           0, 0, cas_arg));
   }
 
   /**
@@ -635,15 +639,14 @@ public:
                 const std::vector<char> &value,
                 uint64_t cas_arg)
   {
-    memcached_return_t rc= memcached_cas_by_key(memc,
-                                                master_key.c_str(),
-                                                master_key.length(),
-                                                key.c_str(),
-                                                key.length(),
-                                                &value[0],
-                                                value.size(),
-                                                0, 0, cas_arg);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_cas_by_key(memc,
+                                                  master_key.c_str(),
+                                                  master_key.length(),
+                                                  key.c_str(),
+                                                  key.length(),
+                                                  &value[0],
+                                                  value.size(),
+                                                  0, 0, cas_arg));
   }
 
   /**
@@ -654,8 +657,7 @@ public:
    */
   bool remove(const std::string &key)
   {
-    memcached_return_t rc= memcached_delete(memc, key.c_str(), key.length(), 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_delete(memc, key.c_str(), key.length(), 0));
   }
 
   /**
@@ -667,11 +669,10 @@ public:
    */
   bool remove(const std::string &key, time_t expiration)
   {
-    memcached_return_t rc= memcached_delete(memc,
-                                            key.c_str(),
-                                            key.length(),
-                                            expiration);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_delete(memc,
+                                              key.c_str(),
+                                              key.length(),
+                                              expiration));
   }
 
   /**
@@ -684,13 +685,12 @@ public:
   bool removeByKey(const std::string &master_key,
                    const std::string &key)
   {
-    memcached_return_t rc= memcached_delete_by_key(memc,
-                                                   master_key.c_str(),
-                                                   master_key.length(),
-                                                   key.c_str(),
-                                                   key.length(),
-                                                   0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_delete_by_key(memc,
+                                                     master_key.c_str(),
+                                                     master_key.length(),
+                                                     key.c_str(),
+                                                     key.length(),
+                                                     0));
   }
 
   /**
@@ -705,13 +705,12 @@ public:
                    const std::string &key,
                    time_t expiration)
   {
-    memcached_return_t rc= memcached_delete_by_key(memc,
-                                                   master_key.c_str(),
-                                                   master_key.length(),
-                                                   key.c_str(),
-                                                   key.length(),
-                                                   expiration);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_delete_by_key(memc,
+                                                     master_key.c_str(),
+                                                     master_key.length(),
+                                                     key.c_str(),
+                                                     key.length(),
+                                                     expiration));
   }
 
   /**
@@ -721,10 +720,9 @@ public:
    *                       memcached servers
    * @return true on success; false otherwise
    */
-  bool flush(time_t expiration)
+  bool flush(time_t expiration= 0)
   {
-    memcached_return_t rc= memcached_flush(memc, expiration);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_flush(memc, expiration));
   }
 
   /**