X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fmemcached.hh;h=c6c3ef5e60f2a0e58e0f10b1bc2a27b38125ff71;hb=d8394605ecf1b1904058c00dfe39a2de4dc0d20d;hp=4e22b61cd22edc5e0c21eaa7a3e7f18d1df1f07b;hpb=7b548d21a8eafec0b830ad1bd6429cecd4eaeba8;p=m6w6%2Flibmemcached diff --git a/libmemcached/memcached.hh b/libmemcached/memcached.hh index 4e22b61c..c6c3ef5e 100644 --- a/libmemcached/memcached.hh +++ b/libmemcached/memcached.hh @@ -1,6 +1,7 @@ #include #include +#include class Memcached { @@ -27,22 +28,26 @@ public: memcached_free(&memc); } - std::string fetch(std::string& key, size_t *key_length, size_t *value_length) + bool fetch(std::string &key, + std::string &ret_val, + size_t *key_length, + size_t *value_length, + uint32_t *flags, + memcached_return *rc) { - uint32_t flags; - memcached_return rc; - std::string ret_val; - - char *value= memcached_fetch(&memc, const_cast(key.c_str()), key_length, - value_length, &flags, &rc); + char ret_key[MEMCACHED_MAX_KEY]; + char *value= memcached_fetch(&memc, ret_key, key_length, + value_length, flags, rc); if (value) { ret_val.assign(value); + key.assign(ret_key); + return true; } - return ret_val; + return false; } - std::string get(const std::string& key, size_t *value_length) + std::string get(const std::string &key, size_t *value_length) { uint32_t flags; memcached_return rc; @@ -57,8 +62,8 @@ public: return ret_val; } - std::string get_by_key(const std::string& master_key, - const std::string& key, + std::string get_by_key(const std::string &master_key, + const std::string &key, size_t *value_length) { uint32_t flags; @@ -75,44 +80,102 @@ public: return ret_val; } - bool mget(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 *. + */ + real_keys.reserve(keys.size()); + key_len.reserve(keys.size()); + + std::vector::iterator it= keys.begin(); + + while (it != keys.end()) + { + real_keys.push_back(const_cast((*it).c_str())); + key_len.push_back((*it).length()); + ++it; + } - memcached_return rc= memcached_mget(&memc, keys, key_length, number_of_keys); - return (rc == MEMCACHED_SUCCESS); + /* + * 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], + real_keys.size()); + return (rc == MEMCACHED_SUCCESS); + } + + return false; } - bool set(const std::string& key, const std::string& value) + bool set(const std::string &key, + const std::string &value, + time_t expiration, + uint32_t flags) { memcached_return rc= memcached_set(&memc, key.c_str(), key.length(), value.c_str(), value.length(), - time_t(0), uint32_t(0)); - return (rc == MEMCACHED_SUCCESS); + expiration, flags); + return (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); } - bool set_by_key(const std::string& master_key, - const std::string& key, - const std::string& value) + bool set_all(std::vector &keys, + std::vector &values, + time_t expiration, + uint32_t flags) + { + 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; + } + + bool set_by_key(const std::string &master_key, + const std::string &key, + const std::string &value, + time_t expiration, + uint32_t flags) { 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(), - time_t(0), - uint32_t(0)); + expiration, + flags); return (rc == MEMCACHED_SUCCESS); } - bool increment(const std::string& 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) + bool decrement(const std::string &key, unsigned int offset, uint64_t *value) { memcached_return rc= memcached_decrement(&memc, key.c_str(), key.length(), @@ -121,15 +184,16 @@ public: } - bool add(const std::string& key, const std::string& value, size_t value_length) + bool add(const std::string &key, const std::string &value) { memcached_return rc= memcached_add(&memc, key.c_str(), key.length(), - value.c_str(), value_length, 0, 0); + value.c_str(), value.length(), 0, 0); return (rc == MEMCACHED_SUCCESS); } - bool add_by_key(const std::string& master_key, const std::string& key, - const std::string& value, size_t value_length) + bool add_by_key(const std::string &master_key, + const std::string &key, + const std::string &value) { memcached_return rc= memcached_add_by_key(&memc, master_key.c_str(), @@ -137,22 +201,22 @@ public: key.c_str(), key.length(), value.c_str(), - value_length, + value.length(), 0, 0); return (rc == MEMCACHED_SUCCESS); } - bool replace(const std::string& key, const std::string& value, - size_t value_length) + bool replace(const std::string &key, const std::string &value) { memcached_return rc= memcached_replace(&memc, key.c_str(), key.length(), - value.c_str(), value_length, + value.c_str(), value.length(), 0, 0); return (rc == MEMCACHED_SUCCESS); } - bool replace_by_key(const std::string& master_key, const std::string& key, - const std::string& value, size_t value_length) + bool replace_by_key(const std::string &master_key, + const std::string &key, + const std::string &value) { memcached_return rc= memcached_replace_by_key(&memc, master_key.c_str(), @@ -160,21 +224,21 @@ public: key.c_str(), key.length(), value.c_str(), - value_length, + value.length(), 0, 0); return (rc == MEMCACHED_SUCCESS); } - bool prepend(const std::string& key, const std::string& value, - size_t value_length) + bool prepend(const std::string &key, const std::string &value) { memcached_return rc= memcached_prepend(&memc, key.c_str(), key.length(), - value.c_str(), value_length, 0, 0); + value.c_str(), value.length(), 0, 0); return (rc == MEMCACHED_SUCCESS); } - bool prepend_by_key(const std::string& master_key, const std::string& key, - const std::string& value, size_t value_length) + bool prepend_by_key(const std::string &master_key, + const std::string &key, + const std::string &value) { memcached_return rc= memcached_prepend_by_key(&memc, master_key.c_str(), @@ -182,25 +246,26 @@ public: key.c_str(), key.length(), value.c_str(), - value_length, + value.length(), 0, 0); return (rc == MEMCACHED_SUCCESS); } - bool append(const std::string& key, const std::string& value, - size_t value_length) + bool append(const std::string &key, const std::string &value) { memcached_return rc= memcached_append(&memc, key.c_str(), key.length(), value.c_str(), - value_length, 0, 0); + value.length(), + 0, 0); return (rc == MEMCACHED_SUCCESS); } - bool append_by_key(const std::string& master_key, const std::string& key, - const std::string& value, size_t value_length) + bool append_by_key(const std::string &master_key, + const std::string &key, + const std::string &value) { memcached_return rc= memcached_append_by_key(&memc, master_key.c_str(), @@ -208,20 +273,24 @@ public: key.c_str(), key.length(), value.c_str(), - value_length, 0, 0); + value.length(), + 0, 0); return (rc == MEMCACHED_SUCCESS); } - bool cas(const std::string& key, const std::string& value, - size_t value_length, uint64_t cas_arg) + bool cas(const std::string &key, + const std::string &value, + uint64_t cas_arg) { memcached_return rc= memcached_cas(&memc, key.c_str(), key.length(), - value.c_str(), value_length, 0, 0, cas_arg); + value.c_str(), value.length(), + 0, 0, cas_arg); return (rc == MEMCACHED_SUCCESS); } - bool cas_by_key(const std::string& master_key, const std::string& key, - const std::string& value, size_t value_length, + bool cas_by_key(const std::string &master_key, + const std::string &key, + const std::string &value, uint64_t cas_arg) { memcached_return rc= memcached_cas_by_key(&memc, @@ -230,20 +299,20 @@ public: key.c_str(), key.length(), value.c_str(), - value_length, + value.length(), 0, 0, cas_arg); return (rc == MEMCACHED_SUCCESS); } // using 'remove' vs. 'delete' since 'delete' is a keyword - bool remove(const std::string& key) + bool remove(const std::string &key) { memcached_return rc= memcached_delete(&memc, key.c_str(), key.length(), 0); return (rc == MEMCACHED_SUCCESS); } - bool delete_by_key(const std::string& master_key, - const std::string& key) + bool delete_by_key(const std::string &master_key, + const std::string &key) { memcached_return rc= memcached_delete_by_key(&memc, master_key.c_str(), @@ -254,6 +323,23 @@ public: return (rc == MEMCACHED_SUCCESS); } + bool flush(time_t expiration) + { + memcached_return rc= memcached_flush(&memc, expiration); + return (rc == MEMCACHED_SUCCESS); + } + + bool fetch_execute(memcached_execute_function *callback, + void *context, + unsigned int num_of_callbacks) + { + memcached_return rc= memcached_fetch_execute(&memc, + callback, + context, + num_of_callbacks); + return (rc == MEMCACHED_SUCCESS); + } + const std::string lib_version() const { const char *ver= memcached_lib_version();