Merged (and removed Malloc for size_t in mget)

diff --cc ChangeLog
index 57659935efd828feb7e0c530ff8dfe9444a55a83,57659935efd828feb7e0c530ff8dfe9444a55a83..aefae4f1220297304eaa2b2a983e13e74098087a
--- 1/ChangeLog
--- 2/ChangeLog
+++ b/ChangeLog
@@@ -1,3 -1,3 +1,6 @@@
++  * Fix for OSX compiles in development builds.
++  * Updated C++ interface.
++
  0.31 Fri Jul 10 09:02:50 PDT 2009
    * Added support or HA via replication.
    * malloc() removed for server key usage.

diff --cc libmemcached/memcached.hh
index d13ca23a7c0217d3811bac7a5e60536c193f02a4,689a3bce068f21ff8421a33f264836d2f75f7b6f..52ce4105d9ef7a6471816f43719e19c0fb928e02
--- 1/libmemcached/memcached.hh
--- 2/libmemcached/memcached.hh
+++ b/libmemcached/memcached.hh
@@@ -40,46 -68,120 +68,119 @@@ public
    {
      uint32_t flags;
      memcached_return rc;
+     std::string ret_val;
  
-     return memcached_get_by_key(&memc, master_key, strlen(master_key), 
-                                 key, strlen(key),
-                                 value_length, &flags, &rc);
+     char *value= memcached_get_by_key(&memc, master_key.c_str(), master_key.length(), 
+                                       key.c_str(), key.length(),
+                                       value_length, &flags, &rc);
+     if (value)
+     {
+       ret_val.assign(value);
+     }
+     return ret_val;
    }
  
-   memcached_return mget(const char **keys, size_t *key_length, 
-                         unsigned int number_of_keys)
+   bool mget(std::vector<std::string> &keys)
    {
 -    size_t *key_len= static_cast<size_t *>(malloc(keys.size() * sizeof(size_t)));
 -    if (key_len == NULL)
 -    {
 -      return false;
 -    }
 -    std::vector<char *> real_keys;
++    std::vector<const char *> real_keys;
++    std::vector<size_t> key_len;
+     /*
+      * Construct an array which will contain the length
+      * of each of the strings in the input vector. Also, to
+      * interface with the memcached C API, we need to convert
+      * the vector of std::string's to a vector of char *.
+      */
 -    int i= 0;
++    real_keys.reserve(keys.size());
++    key_len.reserve(keys.size());
++
+     std::vector<std::string>::iterator it= keys.begin();
 -      key_len[i++]= (*it).length();
++
+     while (it != keys.end())
+     {
+       real_keys.push_back(const_cast<char *>((*it).c_str()));
 -      memcached_return rc= memcached_mget(&memc, &real_keys[0], key_len, 
++      key_len.push_back((*it).length());
+       ++it;
+     }
+ 
+     /*
+      * If the std::vector of keys is empty then we cannot 
+      * call memcached_mget as we will get undefined behavior.
+      */
+     if (!real_keys.empty())
+     {
++      memcached_return rc= memcached_mget(&memc, &real_keys[0], &key_len[0], 
+                                           static_cast<unsigned int>(real_keys.size()));
+       return (rc == MEMCACHED_SUCCESS);
+     }
  
-     return memcached_mget(&memc, keys, key_length, number_of_keys);
+     return false;
    }
  
-   memcached_return set(const char *key, const char *value, size_t value_length)
+   bool set(const std::string &key, 
+            const std::string &value,
+            time_t expiration,
+            uint32_t flags)
    {
-     return memcached_set(&memc, key, strlen(key),
-                          value, value_length,
-                          time_t(0), uint32_t(0));
+     memcached_return rc= memcached_set(&memc, 
+                                        key.c_str(), key.length(),
+                                        value.c_str(), value.length(),
+                                        expiration, flags);
+     return (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
    }
  
-   memcached_return set_by_key(const char *master_key, const char *key, 
-                               const char *value, size_t value_length)
+   bool set_all(std::vector<std::string> &keys,
+                std::vector<std::string> &values,
+                time_t expiration,
+                uint32_t flags)
    {
-     return memcached_set_by_key(&memc, master_key, strlen(master_key),
-                          key, strlen(key),
-                          value, value_length,
-                          time_t(0),
-                          uint32_t(0) );
+     if (keys.size() != values.size())
+     {
+       return false;
+     }
+     bool retval= true;
+     std::vector<std::string>::iterator key_it= keys.begin();
+     std::vector<std::string>::iterator val_it= values.begin();
+     while (key_it != keys.end())
+     {
+       retval= set((*key_it), (*val_it), expiration, flags);
+       if (retval == false)
+       {
+         return retval;
+       }
+       ++key_it;
+       ++val_it;
+     }
+     return retval;
    }
-   memcached_return
-     increment(const char *key, unsigned int offset, uint64_t *value)
+ 
+   bool set_by_key(const std::string &master_key, 
+                   const std::string &key, 
+                   const std::string &value,
+                   time_t expiration,
+                   uint32_t flags)
    {
-     return memcached_increment(&memc, key, strlen(key),
-                          offset, value);
+     memcached_return rc= memcached_set_by_key(&memc, master_key.c_str(), 
+                                               master_key.length(),
+                                               key.c_str(), key.length(),
+                                               value.c_str(), value.length(),
+                                               expiration,
+                                               flags);
+     return (rc == MEMCACHED_SUCCESS);
    }
-   memcached_return
-     decrement(const char *key, unsigned int offset, uint64_t *value)
+ 
+   bool increment(const std::string &key, unsigned int offset, uint64_t *value)
+   {
+     memcached_return rc= memcached_increment(&memc, key.c_str(), key.length(),
+                                              offset, value);
+     return (rc == MEMCACHED_SUCCESS);
+   }
+ 
+   bool decrement(const std::string &key, unsigned int offset, uint64_t *value)
    {
-     return memcached_decrement(&memc, key, strlen(key),
-                          offset, value);
+     memcached_return rc= memcached_decrement(&memc, key.c_str(), 
+                                              key.length(),
+                                              offset, value);
+     return (rc == MEMCACHED_SUCCESS);
    }