From c4706160965fc3996b8c6dc25e899ca36b2c3058 Mon Sep 17 00:00:00 2001 From: Padraig O'Sullivan Date: Sat, 18 Jul 2009 16:35:03 -0400 Subject: [PATCH] Updated the C++ interface to return values as std::vector instead of std::string. Also updated functions that take values as parameters to take std::vector instead. Removed the need for an explicit value_length since we can determine this from the size of the vector. --- libmemcached/memcached.hh | 56 +++++++++-------- tests/plus.cpp | 122 +++++++++++++++++++++++++++----------- 2 files changed, 120 insertions(+), 58 deletions(-) diff --git a/libmemcached/memcached.hh b/libmemcached/memcached.hh index 67262440..fa535c0c 100644 --- a/libmemcached/memcached.hh +++ b/libmemcached/memcached.hh @@ -11,6 +11,8 @@ #include +#include + #include #include @@ -40,54 +42,58 @@ public: } bool fetch(std::string &key, - std::string &ret_val, - size_t *key_length, - size_t *value_length, + std::vector &ret_val, uint32_t *flags, memcached_return *rc) { char ret_key[MEMCACHED_MAX_KEY]; - char *value= memcached_fetch(&memc, ret_key, key_length, - value_length, flags, rc); + size_t value_length= 0; + size_t key_length= 0; + char *value= memcached_fetch(&memc, ret_key, &key_length, + &value_length, flags, rc); if (value) { - ret_val.assign(value); + ret_val.reserve(value_length); + memcpy(&*ret_val.begin(), value, value_length); key.assign(ret_key); return true; } return false; } - std::string get(const std::string &key, size_t *value_length) + std::vector &get(const std::string &key, + std::vector &ret_val) { - uint32_t flags; + uint32_t flags= 0; memcached_return rc; - std::string ret_val; + size_t value_length= 0; char *value= memcached_get(&memc, key.c_str(), key.length(), - value_length, &flags, &rc); - if (value) + &value_length, &flags, &rc); + if (value != NULL) { - ret_val.assign(value); + ret_val.reserve(value_length); + memcpy(&ret_val[0], value, value_length); } return ret_val; } - std::string getByKey(const std::string &master_key, - const std::string &key, - size_t *value_length) + std::vector &getByKey(const std::string &master_key, + const std::string &key, + std::vector &ret_val) { - uint32_t flags; + uint32_t flags= 0; memcached_return rc; - std::string ret_val; + size_t value_length= 0; char *value= memcached_get_by_key(&memc, master_key.c_str(), master_key.length(), key.c_str(), key.length(), - value_length, &flags, &rc); + &value_length, &flags, &rc); if (value) { - ret_val.assign(value); + ret_val.reserve(value_length); + memcpy(&*ret_val.begin(), value, value_length); } return ret_val; } @@ -129,19 +135,19 @@ public: } bool set(const std::string &key, - const std::string &value, + const std::vector &value, time_t expiration, uint32_t flags) { memcached_return rc= memcached_set(&memc, key.c_str(), key.length(), - value.c_str(), value.length(), + &value[0], value.size(), expiration, flags); return (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); } bool setAll(std::vector &keys, - std::vector &values, + std::vector< std::vector > &values, time_t expiration, uint32_t flags) { @@ -151,7 +157,7 @@ public: } bool retval= true; std::vector::iterator key_it= keys.begin(); - std::vector::iterator val_it= values.begin(); + std::vector< std::vector >::iterator val_it= values.begin(); while (key_it != keys.end()) { retval= set((*key_it), (*val_it), expiration, flags); @@ -167,14 +173,14 @@ public: bool setByKey(const std::string &master_key, const std::string &key, - const std::string &value, + const std::vector &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(), + &value[0], value.size(), expiration, flags); return (rc == MEMCACHED_SUCCESS); diff --git a/tests/plus.cpp b/tests/plus.cpp index c21df307..28d72870 100644 --- a/tests/plus.cpp +++ b/tests/plus.cpp @@ -33,17 +33,36 @@ extern "C" { void world_destroy(void *p); } +static void populate_vector(vector &vec, const string &str) +{ + vec.reserve(str.length()); + memcpy(&*vec.begin(), str.c_str(), str.length()); +} + +static void copy_vec_to_string(vector &vec, string &str) +{ + str.clear(); + char *tmp= static_cast(malloc(vec.size() * sizeof(char))); + if (!vec.empty()) + { + memcpy(tmp, &vec[0], vec.size()); + str.assign(tmp); + } +} + test_return basic_test(memcached_st *memc) { Memcached foo(memc); const string value_set("This is some data"); - string value; - size_t value_length; + std::vector value; + std::vector test_value; + + populate_vector(value, value_set); - foo.set("mine", value_set, 0, 0); - value= foo.get("mine", &value_length); + foo.set("mine", value, 0, 0); + test_value= foo.get("mine", test_value); - assert((memcmp(value.c_str(), value_set.c_str(), value_length) == 0)); + assert((memcmp(&test_value[0], &value[0], test_value.size()) == 0)); return TEST_SUCCESS; } @@ -52,18 +71,32 @@ test_return increment_test(memcached_st *memc) { Memcached mcach(memc); bool rc; - const string key("inctest"); + const string key("blah"); const string inc_value("1"); - string ret_value; + std::vector inc_val; + vector ret_value; + string ret_string; uint64_t int_inc_value; uint64_t int_ret_value; - size_t value_length; - mcach.set(key, inc_value, 0, 0); - ret_value= mcach.get(key, &value_length); - printf("\nretvalue %s\n",ret_value.c_str()); + populate_vector(inc_val, inc_value); + + rc= mcach.set(key, inc_val, 0, 0); + if (rc == false) + { + return TEST_FAILURE; + } + ret_value= mcach.get(key, ret_value); + if (ret_value.empty()) + { + return TEST_FAILURE; + } + copy_vec_to_string(ret_value, ret_string); + + printf("string is: %s\n", ret_string.c_str()); + int_inc_value= uint64_t(atol(inc_value.c_str())); - int_ret_value= uint64_t(atol(ret_value.c_str())); + int_ret_value= uint64_t(atol(ret_string.c_str())); assert(int_ret_value == int_inc_value); rc= mcach.increment(key, 1, &int_ret_value); @@ -85,19 +118,23 @@ test_return basic_master_key_test(memcached_st *memc) { Memcached foo(memc); const string value_set("Data for server A"); + vector value; + vector test_value; const string master_key_a("server-a"); const string master_key_b("server-b"); const string key("xyz"); - string value; - size_t value_length; - foo.setByKey(master_key_a, key, value_set, 0, 0); - value= foo.getByKey(master_key_a, key, &value_length); + populate_vector(value, value_set); + + foo.setByKey(master_key_a, key, value, 0, 0); + test_value= foo.getByKey(master_key_a, key, test_value); + + assert((memcmp(&value[0], &test_value[0], value.size()) == 0)); - assert((memcmp(value.c_str(), value_set.c_str(), value_length) == 0)); + test_value.clear(); - value= foo.getByKey(master_key_b, key, &value_length); - assert((memcmp(value.c_str(), value_set.c_str(), value_length) == 0)); + test_value= foo.getByKey(master_key_b, key, test_value); + assert((memcmp(&value[0], &test_value[0], value.size()) == 0)); return TEST_SUCCESS; } @@ -122,16 +159,27 @@ test_return mget_result_function(memcached_st *memc) string key2("son"); string key3("food"); vector keys; + vector< vector > values; + vector val1; + vector val2; + vector val3; + populate_vector(val1, key1); + populate_vector(val2, key2); + populate_vector(val3, key3); keys.reserve(3); keys.push_back(key1); keys.push_back(key2); keys.push_back(key3); + values.reserve(3); + values.push_back(val1); + values.push_back(val2); + values.push_back(val3); unsigned int counter; memcached_execute_function callbacks[1]; /* We need to empty the server before we continue the test */ rc= mc.flush(0); - rc= mc.setAll(keys, keys, 50, 9); + rc= mc.setAll(keys, values, 50, 9); assert(rc == true); rc= mc.mget(keys); @@ -152,16 +200,25 @@ test_return mget_test(memcached_st *memc) bool rc; memcached_return mc_rc; vector keys; + vector< vector > values; keys.reserve(3); keys.push_back("fudge"); keys.push_back("son"); keys.push_back("food"); + vector val1; + vector val2; + vector val3; + populate_vector(val1, "fudge"); + populate_vector(val2, "son"); + populate_vector(val3, "food"); + values.reserve(3); + values.push_back(val1); + values.push_back(val2); + values.push_back(val3); uint32_t flags; string return_key; - size_t return_key_length; - string return_value; - size_t return_value_length; + vector return_value; /* We need to empty the server before we continue the test */ rc= mc.flush(0); @@ -170,27 +227,26 @@ test_return mget_test(memcached_st *memc) rc= mc.mget(keys); assert(rc == true); - while (mc.fetch(return_key, return_value, &return_key_length, - &return_value_length, &flags, &mc_rc)) + while (mc.fetch(return_key, return_value, + &flags, &mc_rc)) { - assert(return_value.length() != 0); + assert(return_value.size() != 0); + return_value.clear(); } - assert(return_value_length == 0); assert(mc_rc == MEMCACHED_END); - rc= mc.setAll(keys, keys, 50, 9); + rc= mc.setAll(keys, values, 50, 9); assert(rc == true); rc= mc.mget(keys); assert(rc == true); - while ((mc.fetch(return_key, return_value, &return_key_length, - &return_value_length, &flags, &mc_rc))) + while ((mc.fetch(return_key, return_value, + &flags, &mc_rc))) { - assert(return_value.length() != 0); assert(mc_rc == MEMCACHED_SUCCESS); - assert(return_key_length == return_value_length); - assert(!memcmp(return_value.c_str(), return_key.c_str(), return_value_length)); + assert(return_key.length() == return_value.size()); + assert(!memcmp(&return_value[0], return_key.c_str(), return_value.size())); } return TEST_SUCCESS; -- 2.30.2