git.m6w6.name Git - awesomized/libmemcached/blob - libmemcached/memcached.hh

   1 #include <libmemcached/memcached.h>
   2
   3 #include <string>
   4 #include <vector>
   5
   6 class Memcached
   7 {
   8 public:
   9
  10   Memcached()
  11     :
  12       memc(),
  13       result()
  14   {
  15     memcached_create(&memc);
  16   }
  17
  18   Memcached(memcached_st *clone)
  19     :
  20       memc(),
  21       result()
  22   {
  23     memcached_clone(&memc, clone);
  24   }
  25
  26   ~Memcached()
  27   {
  28     memcached_free(&memc);
  29   }
  30
  31   std::string fetch(std::string &key, size_t *key_length, size_t *value_length)
  32   {
  33     uint32_t flags;
  34     memcached_return rc;
  35     std::string ret_val;
  36
  37     char *value= memcached_fetch(&memc, const_cast<char *>(key.c_str()), key_length,
  38                                  value_length, &flags, &rc);
  39     if (value)
  40     {
  41       ret_val.assign(value);
  42     }
  43     return ret_val;
  44   }
  45
  46   std::string get(const std::string &key, size_t *value_length)
  47   {
  48     uint32_t flags;
  49     memcached_return rc;
  50     std::string ret_val;
  51
  52     char *value= memcached_get(&memc, key.c_str(), key.length(),
  53                                value_length, &flags, &rc);
  54     if (value)
  55     {
  56       ret_val.assign(value);
  57     }
  58     return ret_val;
  59   }
  60
  61   std::string get_by_key(const std::string &master_key,
  62                          const std::string &key,
  63                          size_t *value_length)
  64   {
  65     uint32_t flags;
  66     memcached_return rc;
  67     std::string ret_val;
  68
  69     char *value= memcached_get_by_key(&memc, master_key.c_str(), master_key.length(),
  70                                       key.c_str(), key.length(),
  71                                       value_length, &flags, &rc);
  72     if (value)
  73     {
  74       ret_val.assign(value);
  75     }
  76     return ret_val;
  77   }
  78
  79   bool mget(std::vector<std::string> &keys)
  80   {
  81     /*
  82      * Construct an array which will contain the length
  83      * of each of the strings in the input vector. Also, to
  84      * interface with the memcached C API, we need to convert
  85      * the vector of std::string's to a vector of char *.
  86      */
  87     size_t *key_len= static_cast<size_t *>(malloc(keys.size() * sizeof(size_t)));
  88     if (key_len == NULL)
  89     {
  90       return false;
  91     }
  92     std::vector<char *> real_keys;
  93     std::vector<std::string>::iterator it= keys.begin();
  94     int i= 0;
  95     while (it != keys.end())
  96     {
  97       real_keys.push_back(const_cast<char *>((*it).c_str()));
  98       key_len[i++]= (*it).length();
  99       ++it;
 100     }
 101
 102     /*
 103      * If the std::vector of keys is empty then we cannot
 104      * call memcached_mget as we will get undefined behavior.
 105      */
 106     if (!real_keys.empty())
 107     {
 108       memcached_return rc= memcached_mget(&memc, &real_keys[0], key_len,
 109                                           static_cast<unsigned int>(real_keys.size()));
 110       return (rc == MEMCACHED_SUCCESS);
 111     }
 112
 113     return false;
 114   }
 115
 116   bool set(const std::string &key, const std::string &value)
 117   {
 118     memcached_return rc= memcached_set(&memc,
 119                                        key.c_str(), key.length(),
 120                                        value.c_str(), value.length(),
 121                                        time_t(0), uint32_t(0));
 122     return (rc == MEMCACHED_SUCCESS);
 123   }
 124
 125   bool set_by_key(const std::string &master_key,
 126                   const std::string &key,
 127                   const std::string &value)
 128   {
 129     memcached_return rc= memcached_set_by_key(&memc, master_key.c_str(),
 130                                               master_key.length(),
 131                                               key.c_str(), key.length(),
 132                                               value.c_str(), value.length(),
 133                                               time_t(0),
 134                                               uint32_t(0));
 135     return (rc == MEMCACHED_SUCCESS);
 136   }
 137
 138   bool increment(const std::string &key, unsigned int offset, uint64_t *value)
 139   {
 140     memcached_return rc= memcached_increment(&memc, key.c_str(), key.length(),
 141                                              offset, value);
 142     return (rc == MEMCACHED_SUCCESS);
 143   }
 144
 145   bool decrement(const std::string &key, unsigned int offset, uint64_t *value)
 146   {
 147     memcached_return rc= memcached_decrement(&memc, key.c_str(),
 148                                              key.length(),
 149                                              offset, value);
 150     return (rc == MEMCACHED_SUCCESS);
 151   }
 152
 153
 154   bool add(const std::string &key, const std::string &value)
 155   {
 156     memcached_return rc= memcached_add(&memc, key.c_str(), key.length(),
 157                                        value.c_str(), value.length(), 0, 0);
 158     return (rc == MEMCACHED_SUCCESS);
 159   }
 160
 161   bool add_by_key(const std::string &master_key,
 162                   const std::string &key,
 163                   const std::string &value)
 164   {
 165     memcached_return rc= memcached_add_by_key(&memc,
 166                                               master_key.c_str(),
 167                                               master_key.length(),
 168                                               key.c_str(),
 169                                               key.length(),
 170                                               value.c_str(),
 171                                               value.length(),
 172                                               0, 0);
 173     return (rc == MEMCACHED_SUCCESS);
 174   }
 175
 176   bool replace(const std::string &key, const std::string &value)
 177   {
 178     memcached_return rc= memcached_replace(&memc, key.c_str(), key.length(),
 179                                            value.c_str(), value.length(),
 180                                            0, 0);
 181     return (rc == MEMCACHED_SUCCESS);
 182   }
 183
 184   bool replace_by_key(const std::string &master_key,
 185                       const std::string &key,
 186                       const std::string &value)
 187   {
 188     memcached_return rc= memcached_replace_by_key(&memc,
 189                                                   master_key.c_str(),
 190                                                   master_key.length(),
 191                                                   key.c_str(),
 192                                                   key.length(),
 193                                                   value.c_str(),
 194                                                   value.length(),
 195                                                   0, 0);
 196     return (rc == MEMCACHED_SUCCESS);
 197   }
 198
 199   bool prepend(const std::string &key, const std::string &value)
 200   {
 201     memcached_return rc= memcached_prepend(&memc, key.c_str(), key.length(),
 202                                            value.c_str(), value.length(), 0, 0);
 203     return (rc == MEMCACHED_SUCCESS);
 204   }
 205
 206   bool prepend_by_key(const std::string &master_key,
 207                       const std::string &key,
 208                       const std::string &value)
 209   {
 210     memcached_return rc= memcached_prepend_by_key(&memc,
 211                                                   master_key.c_str(),
 212                                                   master_key.length(),
 213                                                   key.c_str(),
 214                                                   key.length(),
 215                                                   value.c_str(),
 216                                                   value.length(),
 217                                                   0,
 218                                                   0);
 219     return (rc == MEMCACHED_SUCCESS);
 220   }
 221
 222   bool append(const std::string &key, const std::string &value)
 223   {
 224     memcached_return rc= memcached_append(&memc,
 225                                           key.c_str(),
 226                                           key.length(),
 227                                           value.c_str(),
 228                                           value.length(),
 229                                           0, 0);
 230     return (rc == MEMCACHED_SUCCESS);
 231   }
 232
 233   bool append_by_key(const std::string &master_key,
 234                      const std::string &key,
 235                      const std::string &value)
 236   {
 237     memcached_return rc= memcached_append_by_key(&memc,
 238                                                  master_key.c_str(),
 239                                                  master_key.length(),
 240                                                  key.c_str(),
 241                                                  key.length(),
 242                                                  value.c_str(),
 243                                                  value.length(),
 244                                                  0, 0);
 245     return (rc == MEMCACHED_SUCCESS);
 246   }
 247
 248   bool cas(const std::string &key,
 249            const std::string &value,
 250            uint64_t cas_arg)
 251   {
 252     memcached_return rc= memcached_cas(&memc, key.c_str(), key.length(),
 253                                        value.c_str(), value.length(),
 254                                        0, 0, cas_arg);
 255     return (rc == MEMCACHED_SUCCESS);
 256   }
 257
 258   bool cas_by_key(const std::string &master_key,
 259                   const std::string &key,
 260                   const std::string &value,
 261                   uint64_t cas_arg)
 262   {
 263     memcached_return rc= memcached_cas_by_key(&memc,
 264                                               master_key.c_str(),
 265                                               master_key.length(),
 266                                               key.c_str(),
 267                                               key.length(),
 268                                               value.c_str(),
 269                                               value.length(),
 270                                               0, 0, cas_arg);
 271     return (rc == MEMCACHED_SUCCESS);
 272   }
 273
 274   // using 'remove' vs. 'delete' since 'delete' is a keyword
 275   bool remove(const std::string &key)
 276   {
 277     memcached_return rc= memcached_delete(&memc, key.c_str(), key.length(), 0);
 278     return (rc == MEMCACHED_SUCCESS);
 279   }
 280
 281   bool delete_by_key(const std::string &master_key,
 282                      const std::string &key)
 283   {
 284     memcached_return rc= memcached_delete_by_key(&memc,
 285                                                  master_key.c_str(),
 286                                                  master_key.length(),
 287                                                  key.c_str(),
 288                                                  key.length(),
 289                                                  0);
 290     return (rc == MEMCACHED_SUCCESS);
 291   }
 292
 293   const std::string lib_version() const
 294   {
 295     const char *ver= memcached_lib_version();
 296     const std::string version(ver);
 297     return version;
 298   }
 299
 300 private:
 301   memcached_st memc;
 302   memcached_result_st result;
 303 };