From: Brian Aker Date: Wed, 15 Jul 2009 09:05:00 +0000 (-0700) Subject: Merged (and removed Malloc for size_t in mget) X-Git-Tag: 0.32~17 X-Git-Url: https://git.m6w6.name/?a=commitdiff_plain;h=cb05d3311de7e7ca578bafb116f3c8a56b9f0aa8;p=awesomized%2Flibmemcached Merged (and removed Malloc for size_t in mget) --- cb05d3311de7e7ca578bafb116f3c8a56b9f0aa8 diff --cc ChangeLog index 57659935,57659935..aefae4f1 --- a/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 d13ca23a,689a3bce..52ce4105 --- a/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 &keys) { ++ std::vector real_keys; ++ std::vector 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 *. + */ - size_t *key_len= static_cast(malloc(keys.size() * sizeof(size_t))); - if (key_len == NULL) - { - return false; - } - std::vector real_keys; ++ real_keys.reserve(keys.size()); ++ key_len.reserve(keys.size()); ++ + std::vector::iterator it= keys.begin(); - int i= 0; ++ + while (it != keys.end()) + { + real_keys.push_back(const_cast((*it).c_str())); - key_len[i++]= (*it).length(); ++ 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, ++ memcached_return rc= memcached_mget(&memc, &real_keys[0], &key_len[0], + static_cast(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 &keys, + std::vector &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::iterator key_it= keys.begin(); + std::vector::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); }