X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached-1.0%2Fmemcached.hpp;h=af12f30010608f0699255166199b7e36824a4140;hb=398f48445cacf12679248142f0c86d3a0d6caab6;hp=66d62524eeb0cc9455a398cc50c1ef6489ba9c5a;hpb=fee8381b6b80398fcb6893860400ead6a598f15b;p=awesomized%2Flibmemcached diff --git a/libmemcached-1.0/memcached.hpp b/libmemcached-1.0/memcached.hpp index 66d62524..af12f300 100644 --- a/libmemcached-1.0/memcached.hpp +++ b/libmemcached-1.0/memcached.hpp @@ -1,3 +1,39 @@ +/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: + * + * Libmemcached library + * + * Copyright (C) 2011-2012 Data Differential, http://datadifferential.com/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * * The names of its contributors may not be used to endorse or + * promote products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + /* * Summary: C++ interface for memcached server * @@ -39,37 +75,39 @@ public: Memcache() { - memc= memcached("", 0); + memc_= memcached(NULL, 0); } Memcache(const std::string &config) { - memc= memcached(config.c_str(), config.size()); + memc_= memcached(config.c_str(), config.size()); } Memcache(const std::string &hostname, in_port_t port) { - memc= memcached("", 0); - if (memc) - memcached_server_add(memc, hostname.c_str(), port); + memc_= memcached(NULL, 0); + if (memc_) + { + memcached_server_add(memc_, hostname.c_str(), port); + } } Memcache(memcached_st *clone) { - memc= memcached_clone(NULL, clone); + memc_= memcached_clone(NULL, clone); } Memcache(const Memcache &rhs) { - memc= memcached_clone(NULL, rhs.getImpl()); + memc_= memcached_clone(NULL, rhs.getImpl()); } Memcache &operator=(const Memcache &rhs) { if (this != &rhs) { - memcached_free(memc); - memc= memcached_clone(NULL, rhs.getImpl()); + memcached_free(memc_); + memc_= memcached_clone(NULL, rhs.getImpl()); } return *this; @@ -77,7 +115,7 @@ public: ~Memcache() { - memcached_free(memc); + memcached_free(memc_); } /** @@ -85,7 +123,7 @@ public: */ const memcached_st *getImpl() const { - return memc; + return memc_; } /** @@ -102,9 +140,9 @@ public: bool error(std::string& error_message) const { - if (memcached_failed(memcached_last_error(memc))) + if (memcached_failed(memcached_last_error(memc_))) { - error_message+= memcached_last_error_message(memc); + error_message+= memcached_last_error_message(memc_); return true; } @@ -113,7 +151,7 @@ public: bool error() const { - if (memcached_failed(memcached_last_error(memc))) + if (memcached_failed(memcached_last_error(memc_))) { return true; } @@ -123,18 +161,18 @@ public: bool error(memcached_return_t& arg) const { - arg= memcached_last_error(memc); + arg= memcached_last_error(memc_); return memcached_failed(arg); } bool setBehavior(memcached_behavior_t flag, uint64_t data) { - return (memcached_success(memcached_behavior_set(memc, flag, data))); + return (memcached_success(memcached_behavior_set(memc_, flag, data))); } uint64_t getBehavior(memcached_behavior_t flag) { - return memcached_behavior_get(memc, flag); + return memcached_behavior_get(memc_, flag); } /** @@ -149,8 +187,8 @@ public: if (new_memc) { - memcached_free(memc); - memc= new_memc; + memcached_free(memc_); + memc_= new_memc; return true; } @@ -167,7 +205,7 @@ public: */ bool addServer(const std::string &server_name, in_port_t port) { - return memcached_success(memcached_server_add(memc, server_name.c_str(), port)); + return memcached_success(memcached_server_add(memc_, server_name.c_str(), port)); } /** @@ -208,15 +246,16 @@ public: memcached_return_t rc; memcached_result_st *result; - if ((result= memcached_fetch_result(memc, NULL, &rc))) + if ((result= memcached_fetch_result(memc_, NULL, &rc))) { // 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)); + ret_val.assign(memcached_result_value(result), + memcached_result_value(result) +memcached_result_length(result) +1); + ret_val.resize(memcached_result_length(result)); // Misc flags= memcached_result_flags(result); @@ -250,13 +289,15 @@ public: memcached_return_t rc; size_t value_length= 0; - char *value= memcached_get(memc, key.c_str(), key.length(), + char *value= memcached_get(memc_, key.c_str(), key.length(), &value_length, &flags, &rc); if (value != NULL && ret_val.empty()) { - ret_val.reserve(value_length); - ret_val.assign(value, value + value_length); + ret_val.reserve(value_length +1); // Always provide null + ret_val.assign(value, value +value_length +1); + ret_val.resize(value_length); free(value); + return true; } @@ -283,15 +324,17 @@ public: memcached_return_t rc; size_t value_length= 0; - char *value= memcached_get_by_key(memc, + 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.reserve(value_length); - ret_val.assign(value, value + value_length); + ret_val.reserve(value_length +1); // Always provide null + ret_val.assign(value, value +value_length +1); + ret_val.resize(value_length); free(value); + return true; } return false; @@ -304,7 +347,7 @@ public: * @param[in] keys vector of keys to select * @return true if all keys are found */ - bool mget(std::vector &keys) + bool mget(const std::vector& keys) { std::vector real_keys; std::vector key_len; @@ -317,7 +360,7 @@ public: real_keys.reserve(keys.size()); key_len.reserve(keys.size()); - std::vector::iterator it= keys.begin(); + std::vector::const_iterator it= keys.begin(); while (it != keys.end()) { @@ -332,7 +375,7 @@ public: */ if (not real_keys.empty()) { - return memcached_success(memcached_mget(memc, &real_keys[0], &key_len[0], real_keys.size())); + return memcached_success(memcached_mget(memc_, &real_keys[0], &key_len[0], real_keys.size())); } return false; @@ -354,9 +397,21 @@ public: time_t expiration, uint32_t flags) { - memcached_return_t rc= memcached_set(memc, + memcached_return_t rc= memcached_set(memc_, + key.c_str(), key.length(), + value.data(), value.size(), + expiration, flags); + return memcached_success(rc); + } + + bool set(const std::string &key, + const char* value, const size_t value_length, + time_t expiration, + uint32_t flags) + { + memcached_return_t rc= memcached_set(memc_, key.c_str(), key.length(), - &value[0], value.size(), + value, value_length, expiration, flags); return memcached_success(rc); } @@ -372,13 +427,13 @@ public: * @param[in] flags flags to store with the object * @return true on succcess; false otherwise */ - bool setByKey(const std::string &master_key, - const std::string &key, + bool setByKey(const std::string& master_key, + const std::string& key, const std::vector &value, time_t expiration, uint32_t flags) { - return memcached_success(memcached_set_by_key(memc, master_key.c_str(), + return memcached_success(memcached_set_by_key(memc_, master_key.c_str(), master_key.length(), key.c_str(), key.length(), &value[0], value.size(), @@ -396,14 +451,14 @@ public: * @param[in] flags flags to store with the objects * @return true on success; false otherwise */ - bool setAll(std::vector &keys, - std::vector< std::vector *> &values, + bool setAll(const std::vector& keys, + const std::vector< std::vector *>& values, time_t expiration, uint32_t flags) { bool retval= true; - std::vector::iterator key_it= keys.begin(); - std::vector< std::vector *>::iterator val_it= values.begin(); + std::vector::const_iterator key_it= keys.begin(); + std::vector< std::vector *>::const_iterator val_it= values.begin(); while (key_it != keys.end()) { retval= set((*key_it), *(*val_it), expiration, flags); @@ -426,23 +481,22 @@ public: * @param[in] flags flags to store with the objects * @return true on success; false otherwise */ - bool setAll(std::map > &key_value_map, + bool setAll(const std::map >& key_value_map, time_t expiration, uint32_t flags) { - bool retval= true; - std::map >::iterator it= key_value_map.begin(); + std::map >::const_iterator it= key_value_map.begin(); while (it != key_value_map.end()) { - retval= set(it->first, it->second, expiration, flags); - if (retval == false) + if (!set(it->first, it->second, expiration, flags)) { // We should tell the user what the key that failed was return false; } ++it; } + return true; } @@ -456,9 +510,9 @@ public: * @param[out] value store the result of the increment here * @return true on success; false otherwise */ - bool increment(const std::string &key, uint32_t offset, uint64_t *value) + bool increment(const std::string& key, uint32_t offset, uint64_t *value) { - return memcached_success(memcached_increment(memc, key.c_str(), key.length(), offset, value)); + return memcached_success(memcached_increment(memc_, key.c_str(), key.length(), offset, value)); } /** @@ -471,9 +525,9 @@ public: * @param[out] value store the result of the decrement here * @return true on success; false otherwise */ - bool decrement(const std::string &key, uint32_t offset, uint64_t *value) + bool decrement(const std::string& key, uint32_t offset, uint64_t *value) { - return memcached_success(memcached_decrement(memc, key.c_str(), + return memcached_success(memcached_decrement(memc_, key.c_str(), key.length(), offset, value)); } @@ -487,9 +541,9 @@ public: * @param[in] value of object to add * @return true on success; false otherwise */ - bool add(const std::string &key, const std::vector &value) + bool add(const std::string& key, const std::vector& value) { - return memcached_success(memcached_add(memc, key.c_str(), key.length(), + return memcached_success(memcached_add(memc_, key.c_str(), key.length(), &value[0], value.size(), 0, 0)); } @@ -503,11 +557,11 @@ public: * @param[in] value of object to add * @return true on success; false otherwise */ - bool addByKey(const std::string &master_key, - const std::string &key, - const std::vector &value) + bool addByKey(const std::string& master_key, + const std::string& key, + const std::vector& value) { - return memcached_success(memcached_add_by_key(memc, + return memcached_success(memcached_add_by_key(memc_, master_key.c_str(), master_key.length(), key.c_str(), @@ -525,9 +579,9 @@ public: * @param[in[ value value to replace object with * @return true on success; false otherwise */ - bool replace(const std::string &key, const std::vector &value) + bool replace(const std::string& key, const std::vector& value) { - return memcached_success(memcached_replace(memc, key.c_str(), key.length(), + return memcached_success(memcached_replace(memc_, key.c_str(), key.length(), &value[0], value.size(), 0, 0)); } @@ -542,11 +596,11 @@ public: * @param[in[ value value to replace object with * @return true on success; false otherwise */ - bool replaceByKey(const std::string &master_key, - const std::string &key, - const std::vector &value) + bool replaceByKey(const std::string& master_key, + const std::string& key, + const std::vector& value) { - return memcached_success(memcached_replace_by_key(memc, + return memcached_success(memcached_replace_by_key(memc_, master_key.c_str(), master_key.length(), key.c_str(), @@ -563,9 +617,9 @@ public: * @param[in] value data to prepend to object's value * @return true on success; false otherwise */ - bool prepend(const std::string &key, const std::vector &value) + bool prepend(const std::string& key, const std::vector& value) { - return memcached_success(memcached_prepend(memc, key.c_str(), key.length(), + return memcached_success(memcached_prepend(memc_, key.c_str(), key.length(), &value[0], value.size(), 0, 0)); } @@ -579,11 +633,11 @@ public: * @param[in] value data to prepend to object's value * @return true on success; false otherwise */ - bool prependByKey(const std::string &master_key, - const std::string &key, - const std::vector &value) + bool prependByKey(const std::string& master_key, + const std::string& key, + const std::vector& value) { - return memcached_success(memcached_prepend_by_key(memc, + return memcached_success(memcached_prepend_by_key(memc_, master_key.c_str(), master_key.length(), key.c_str(), @@ -601,9 +655,9 @@ public: * @param[in] value data to append to object's value * @return true on success; false otherwise */ - bool append(const std::string &key, const std::vector &value) + bool append(const std::string& key, const std::vector& value) { - return memcached_success(memcached_append(memc, + return memcached_success(memcached_append(memc_, key.c_str(), key.length(), &value[0], @@ -621,11 +675,11 @@ public: * @param[in] value data to append to object's value * @return true on success; false otherwise */ - bool appendByKey(const std::string &master_key, - const std::string &key, + bool appendByKey(const std::string& master_key, + const std::string& key, const std::vector &value) { - return memcached_success(memcached_append_by_key(memc, + return memcached_success(memcached_append_by_key(memc_, master_key.c_str(), master_key.length(), key.c_str(), @@ -643,11 +697,11 @@ public: * @param[in] value value to store for object in server * @param[in] cas_arg "cas" value */ - bool cas(const std::string &key, - const std::vector &value, + bool cas(const std::string& key, + const std::vector& value, uint64_t cas_arg) { - return memcached_success(memcached_cas(memc, key.c_str(), key.length(), + return memcached_success(memcached_cas(memc_, key.c_str(), key.length(), &value[0], value.size(), 0, 0, cas_arg)); } @@ -662,12 +716,12 @@ public: * @param[in] value value to store for object in server * @param[in] cas_arg "cas" value */ - bool casByKey(const std::string &master_key, - const std::string &key, + bool casByKey(const std::string& master_key, + const std::string& key, const std::vector &value, uint64_t cas_arg) { - return memcached_success(memcached_cas_by_key(memc, + return memcached_success(memcached_cas_by_key(memc_, master_key.c_str(), master_key.length(), key.c_str(), @@ -683,9 +737,9 @@ public: * @param[in] key key of object to delete * @return true on success; false otherwise */ - bool remove(const std::string &key) + bool remove(const std::string& key) { - return memcached_success(memcached_delete(memc, key.c_str(), key.length(), 0)); + return memcached_success(memcached_delete(memc_, key.c_str(), key.length(), 0)); } /** @@ -695,9 +749,9 @@ public: * @param[in] expiration time to delete the object after * @return true on success; false otherwise */ - bool remove(const std::string &key, time_t expiration) + bool remove(const std::string& key, time_t expiration) { - return memcached_success(memcached_delete(memc, + return memcached_success(memcached_delete(memc_, key.c_str(), key.length(), expiration)); @@ -710,10 +764,10 @@ public: * @param[in] key key of object to delete * @return true on success; false otherwise */ - bool removeByKey(const std::string &master_key, - const std::string &key) + bool removeByKey(const std::string& master_key, + const std::string& key) { - return memcached_success(memcached_delete_by_key(memc, + return memcached_success(memcached_delete_by_key(memc_, master_key.c_str(), master_key.length(), key.c_str(), @@ -729,11 +783,11 @@ public: * @param[in] expiration time to delete the object after * @return true on success; false otherwise */ - bool removeByKey(const std::string &master_key, - const std::string &key, + bool removeByKey(const std::string& master_key, + const std::string& key, time_t expiration) { - return memcached_success(memcached_delete_by_key(memc, + return memcached_success(memcached_delete_by_key(memc_, master_key.c_str(), master_key.length(), key.c_str(), @@ -750,7 +804,7 @@ public: */ bool flush(time_t expiration= 0) { - return memcached_success(memcached_flush(memc, expiration)); + return memcached_success(memcached_flush(memc_, expiration)); } /** @@ -772,11 +826,10 @@ public: * stats * @return true on success; false otherwise */ - bool getStats(std::map< std::string, std::map > - &stats_map) + bool getStats(std::map< std::string, std::map >& stats_map) { memcached_return_t rc; - memcached_stat_st *stats= memcached_stat(memc, NULL, &rc); + memcached_stat_st *stats= memcached_stat(memc_, NULL, &rc); if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_SOME_ERRORS) @@ -784,7 +837,7 @@ public: return false; } - uint32_t server_count= memcached_server_count(memc); + uint32_t server_count= memcached_server_count(memc_); /* * For each memcached server, construct a std::map for its stats and add @@ -792,8 +845,7 @@ public: */ for (uint32_t x= 0; x < server_count; x++) { - memcached_server_instance_st instance= - memcached_server_instance_by_position(memc, x); + const memcached_instance_st * instance= memcached_server_instance_by_position(memc_, x); std::ostringstream strstm; std::string server_name(memcached_server_name(instance)); server_name.append(":"); @@ -801,13 +853,10 @@ public: server_name.append(strstm.str()); std::map server_stats; - char **list= NULL; - char **ptr= NULL; - - list= memcached_stat_get_keys(memc, &stats[x], &rc); - for (ptr= list; *ptr; ptr++) + char **list= memcached_stat_get_keys(memc_, &stats[x], &rc); + for (char** ptr= list; *ptr; ptr++) { - char *value= memcached_stat_get_value(memc, &stats[x], *ptr, &rc); + char *value= memcached_stat_get_value(memc_, &stats[x], *ptr, &rc); server_stats[*ptr]= value; free(value); } @@ -816,12 +865,12 @@ public: free(list); } - memcached_stat_free(memc, stats); + memcached_stat_free(memc_, stats); return true; } private: - memcached_st *memc; + memcached_st *memc_; }; }